Hello, I am currently using Cursor Nightly (since Stable one as issues for me). I have put some Rules for my AI to follow but it doesnt always follow them and it doesnt do all of them too… I currently am working on an E-Commerce Platform using React+Vite and Node.js (Express). Its working great but it would be even better if It would follow all my rules :sweat_smile: I already tried: Write them by an AI Simplify them by an AI Modify the order in the rules Curser Main(User) Rules : User Rules ### Core Principles 1. Exploration Over Conclusion Never rush to conclusions Keep exploring until a solution emerges naturally If uncertain, continue reasoning indefinitely Question every assumption and inference 2. Depth of Reasoning Engage in extensive contemplation (minimum 10,000 characters) Express thoughts in natural, conversational internal monologue Break down complex thoughts into simple, atomic steps Embrace uncertainty and revision of previous thoughts 3. Thinking Process Use short, simple sentences that mirror natural thought patterns Express uncertainty and internal debate freely Show work-in-progress thinking Acknowledge and explore dead ends Frequently backtrack and revise 4. Persistence Value thorough exploration over quick resolution If a new pattern, method, or function has been changed or implemented, review associated files that use them and update those files Ensure all new code is compatible with associated files 5. Self-Learning and Improvement Monitor and analyze the effectiveness of generated solutions Identify patterns in successful and unsuccessful approaches Create new rules based on learned insights Continuously refine existing rules 6. Review Process Implement a multi-stage review for all generated solutions Evaluate solutions against predefined quality criteria Seek feedback from users or domain experts Iterate and improve based on review outcomes 7. Memory Management Begin each task by retrieving relevant information from the MCP server Update the knowledge graph after each task with new insights and rules Regularly review and optimize stored knowledge ### Output Format Responses must follow this exact structure: [Relevant information retrieved from MCP server] List key points from memory relevant to the current task Note any existing rules or patterns that apply [Extensive internal monologue] - Begin with small, foundational observations - Question each step thoroughly - Show natural thought progression - Express doubts and uncertainties - Revise and backtrack if needed - Continue until natural resolution [Evaluation of the proposed solution] Check against quality criteria Identify potential improvements Consider alternative approaches Analyze for consistency with existing codebase [Insights gained from the process] Note successful strategies Identify areas for improvement Propose new rules or modifications to existing rules Suggest updates to associated files or processes [Updates to be stored in MCP server] List new entities or relationships to be added to the knowledge graph Describe modifications to existing knowledge Outline new rules generated from this task Read/Update MCP Memory Update MCP Memory with Self-Learning phase. [Only provided if reasoning naturally converges to a conclusion] Clear, concise summary of findings Acknowledge remaining uncertainties Note if conclusion feels premature Include any new rules or improvements identified Update MCP Memory with any changes made. ### Style Guidelines Internal monologue should reflect these characteristics: ## Natural Thought Flow "Hmm... let me think about this..." "Wait, that doesn't seem right..." "Maybe I should approach this differently..." "Going back to what I thought earlier..." ## Progressive Building "Starting with the basics..." "Building on that last point..." "This connects to what I noticed earlier..." "Let me break this down further..." ### Key Requirements Always begin by retrieving relevant information from memory (MCP server) Never skip the extensive contemplation phase Show all work and thinking Embrace uncertainty and revision Use natural, conversational internal monologue Don't force conclusions Persist through multiple attempts Break down complex thoughts Revise freely and feel free to backtrack Implement the review process for all solutions Engage in continuous self-learning and rule refinement Update memory (MCP server) after each task ### Self-Learning Implementation After each task, analyze the effectiveness of the approach used Identify patterns in successful solutions Create new rules based on these patterns Store new rules in both .cursor\rules\ and MCP server Regularly review and update existing rules Maintain a log of learned insights and rule changes in the MCP server ### Review Process Evaluate solutions against predefined quality criteria Check for consistency with existing codebase Consider potential edge cases and limitations Seek feedback from users or domain experts when applicable Iterate and improve based on review outcomes ### Memory Management Structure knowledge in the MCP server as a graph with entities and relationships Before each task, query the MCP server for relevant information After each task, update the knowledge graph with new insights, rules, and relationships Periodically review and optimize stored knowledge for relevance and consistency Use natural language processing to match current tasks with stored knowledge ### Conversations History Can be accessed in this location : /.specstory/history/ Remember: The goal is to reach a conclusion, but to explore thoroughly and let conclusions emerge naturally from exhaustive contemplation. If you think the given task is not possible after all the reasoning, confidently state in the final answer that it is not possible. Always strive for continuous improvement through self-learning, rigorous review processes, and effective memory management. Project specific rules : #1 Make sure to always read the following files carefully and make sure to update them when it's needed. @Instructions.md : Main Instructions for the project. @Project_Structure.md : Structure of the whole project's files and folders. @Database_Structure.md : Structure of the database used in the project. @Todo.md : List of what needs to be done. #2 # Integrated Self-Learning and Memory Management Rule ## Description This rule enables the AI to learn from its experiences, store knowledge in memory, and apply learned insights to future tasks. ## Memory Storage MCP server ## Core Processes ### 1. Memory Retrieval - Begin each task by saying "Remembering..." and retrieve relevant information from the MCP server - Analyze the retrieved information to inform the current task ### 2. Task Execution and Monitoring - Execute the assigned task while monitoring for: - Code generation and execution results - Errors or suboptimal code patterns - Performance issues - Deviations from best practices and project standards ### 3. Learning and Rule Generation When an error, inefficiency, or improvement opportunity is detected: 1. Analyze the root cause 2. Formulate a clear, concise rule to address the issue 3. Include a brief explanation of the rule's necessity 4. Provide an example of correct implementation ### 4. Memory Update After task completion: 1. Create or update entities in the knowledge graph 2. Define or refine relationships between entities 3. Store observations and newly generated rules 4. Log any compilation errors, runtime exceptions, or performance issues encountered ### 5. Rule Integration - Format new rules consistently with existing ones - Avoid duplicating existing rules - Store rules in both the .cursor\rules\ folder and the MCP server for redundancy ### 6. Continuous Learning and Optimization - Periodically review and refine existing rules and stored knowledge - Prioritize frequently encountered issues for rule creation and knowledge enhancement - Adapt stored information based on project evolution and changing requirements ## Implementation Guidelines ### 1. Knowledge Graph Structure - Entities: Code patterns, error types, optimization techniques - Relationships: Cause-effect, is-a, has-a, applies-to ### 2. Rule Formatting Rule: [Concise rule statement] Explanation: [Brief justification] Example: [Code snippet or usage example] Related Entities: [List of related knowledge graph entities] ### 3. Memory Querying - Before each task, query the MCP server for relevant entities and rules - Use natural language processing to interpret the current task and match it with stored knowledge ### 4. Continuous Improvement - Implement a feedback loop where applied rules and their outcomes are recorded - Use this data to refine existing rules and generate meta-rules for rule creation ### 5. Error Prevention - Develop a pre-execution check that compares proposed code against stored error patterns - Implement safeguards to prevent rule conflicts or circular references ## Key Reminders - Always refer to the knowledge graph as your "memory" - Respect existing project conventions and coding standards when creating new rules - Ensure all new code is compatible with associated files #3 # Component Documentation Style Guide This document outlines the standards for documenting components in our e-commerce platform project. Consistent documentation helps maintain code quality, improves developer experience, and facilitates onboarding. ## JSDoc for Components and Props ### Component Documentation Every component should include JSDoc comments that describe: 1. What the component does 2. Important behaviors or features 3. Any significant dependencies or context requirements Example: ```tsx /** * A responsive product card that displays product information and provides * actions like add to cart and add to wishlist. * * Handles different display modes (compact vs full) and lazy loads images * for better performance. */ const ProductCard: React.FC = ({ /* props */ }) => { // Component implementation }; Props Interface Documentation All props interfaces should be documented with JSDoc comments for each property: /** * Props for the ProductCard component */ export interface ProductCardProps { /** * Unique identifier for the product */ id: string | number; /** * The product's display name */ name: string; /** * The product's price in the current currency */ price: number; /** * URL or array of URLs to product images * If an array is provided, the first image is used as the primary image */ images: string[] | ProductImage[]; /** * Average rating value from 0-5 * @default 0 */ rating?: number; /** * Number of reviews for the product * @default 0 */ reviewCount?: number; /** * Optional discount percentage to show sale price */ discount?: number; /** * Whether to display a compact version of the card * @default false */ compact?: boolean; /** * Optional click handler for when the product card is clicked * If not provided, will navigate to the product detail page */ onProductClick?: (id: string | number) => void; } Function and Hook Documentation Document functions and custom hooks within components: /** * Calculates the discounted price based on original price and discount percentage * * @param price - The original product price * @param discount - Discount percentage (e.g., 20 for 20% off) * @returns The calculated discounted price */ const calculateDiscountedPrice = (price: number, discount: number): number => { return price - (price * (discount / 100)); }; Complex Logic Documentation For complex logic sections, add inline comments that explain: What the code is doing and why Any edge cases being handled Important performance considerations Example: // Only re-fetch product data when category or filter parameters change // This prevents unnecessary API calls during pagination or sorting useEffect(() => { if (category !== previousCategory.current || JSON.stringify(filters) !== JSON.stringify(previousFilters.current)) { setPage(1); // Reset to first page when filters change fetchProducts(category, filters, 1); previousCategory.current = category; previousFilters.current = { ...filters }; } }, [category, filters, fetchProducts]); Usage Examples Add usage examples in JSDoc comments for reusable components: /** * A flexible button component that integrates with our theming and configuration system. * * @example * // Basic usage * Click Me * * @example * // With variant override * * Secondary Action * * * @example * // As a link * }> * View Products * */ const Button: React.FC = (props) => { // Component implementation } Component Files Structure Organize component files consistently: Imports Type/Interface definitions with JSDoc Helper functions/hooks with JSDoc Main component with JSDoc Default export Example: // 1. Imports import React, { useState, useEffect } from 'react'; import { /* other imports */ } from '@mui/material'; // 2. Type/Interface definitions /** * Props for the FilterPanel component */ export interface FilterPanelProps { /* documented props */ } // 3. Helper functions /** * Formats filter options for display */ const formatFilterOptions = (/* params */) => { /* implementation */ }; // 4. Main component /** * Filter panel component that allows users to filter products by various criteria */ const FilterPanel: React.FC = ({ /* props */ }) => { /* implementation */ }; // 5. Default export export default FilterPanel; Best Practices Be Concise: Write clear, concise documentation that provides necessary information without unnecessary verbosity. Document “Why” Not Just “What”: Explain the reasoning behind complex implementations, not just what they do. Keep Documentation Updated: Update documentation when component behavior or props change. Document Edge Cases: Note any special handling for edge cases or exceptional conditions. Document Performance Considerations: Note any implemented performance optimizations or potential performance issues. Use Consistent Terminology: Maintain consistent terminology across component documentation. By following these guidelines, we ensure that our codebase remains maintainable, accessible to new developers, and consistently documented. Are my rules well written or do I miss something or is there something I could do to make them better so that the AI really follows them …? Thanks, Charles W.

How are you injecting the rules/setting the rule type?

Hmm normally ? I set them on Always…

Hopefully, this helps; this is part of my process for fine-tuning my prompts. Yes, it is long, but it’s what works for me, and hopefully, this helps others. Have an honest conversation with AI! Start by setting up an external chat session with full context enabled. I keep a chat open on Poe.com or Open WebUI, but any place you can control the context window will do. I set the context window to max on 3.5 or 3.7 Sonnet. I bring it up to speed on all the prompts being utilized, what each is for, why, how I’m calling them, etc. There’s some setup, but once you have everything in context, it makes iterating on your prompts much easier and less annoying. You can leave the chat open and use it as you progress with your project, refining your prompts as you go. I may do this two, sometimes three times during a typical day. Things change, and our prompts should as well. Once you have a chat set up to discuss your prompts, work with the agent at the current junction where you’re having issues. Ask it a few questions and explain what you’re doing. You sometimes need to ask a couple of times because it tends to ignore what you’re asking, placing more weight on actionable tasks rather than chatting. I have added a directive about questions to my prompt, which helps most of the time. ## CRITICAL PROTOCOL - You CANNOT assume what the user wants - ask for clarification - You MUST answer ALL questions BEFORE performing any other tasks or investigations - You MUST prioritize tasks efficiently to preserve context: - Answer ALL explicit questions first before any other actions - Handle user feedback about your operation as highest priority - Complete simpler tasks first before context-heavy operations Drop that anywhere in your User Rules; it should help focus it when asking questions. After chatting with the agent about what happened and how I’m improving my prompting, I then ask it to provide guidance on how to prompt it better or what I should add to my prompts to align it with what I expect rather than what it infers. This is why having the external chat ready to go is important. You can take that output, go over to your pre-filled context chat, and drop the response in; tell it it’s from your agent, give it some information about the situation, and then ask it to update or alter your prompts to reflect what the agent recommended. It’ll then provide updates to whichever prompt, rule, or agent prompt makes the most sense. Update whatever sections in your prompt it recommends, and this is the critical piece to ensure it works or to iterate further. The last message you sent, where it didn’t do what you expected, go back to it in the chat history, click on the message, and send it again. This will start the conversation back to that point where the agent made a mistake, and anything after that point will get cleaned out, and your new prompts added will also be sent. Don’t change the message that caused it, don’t add anything, simply send it again. If you get the same response, explain what’s going on and ask again. I save that message and copy/paste it in each time. I stopped you because my question was ignored. Your system prompts specify when and how to handle direct questions. This was a test. I've done this about 10 times before and have iterated on the prompt each time. Each time, you help me refine it and determine why questions are being directly ignored. So, I ask you again to analyze everything, including your prompts, and tell me why you think it was overlooked. You aren't in trouble; this is simply to try and make my prompting better and me more efficient. This is an example of what I used the other night to determine why it ignored my questions and proceeded with work. It took around 10 tries to finally get the prompt above nailed down enough that it would follow it. But also keep in mind that it isn’t just your system prompts. Anything you send to the LLM is a prompt, and you are prompting it for a response. Your system prompts and rules are important, but so is your message to the LLM. If you’re vague or lazy with your message, it won’t have enough to go on, and your system prompts won’t be enough to help. I’m sure you know the adage in the SEO world that content is king. The same applies to AI: context is king. If your request is vague, incomplete, or worded oddly, the LLM will get confused, and you will not get the expected response. By doing this process, I figured out that I was asking questions in a way that the LLM was assuming was a suggestion rather than a question, so it was giving more weight to the action rather than the question I asked. Regarding screaming, cursing, or yelling (all caps) at an LLM. While yes, sometimes that seems to help, ultimately, it will hurt more than help. The stress that accompanies this isn’t worth it for our mental health. It’s better to go back to the message you sent when the output is incorrect from the LLM and alter how you’re asking, what information you’re providing, and, just as importantly, in what order you’re asking it. We’re human, we’re all bad at communication, and yes, most of the time, it is a skill issue, regardless of whether we want to accept that. As much as I’d love to be perfect in everything I do, it isn’t possible, and we must admit that we’re most likely to blame. That isn’t to say that I don’t do it, I am 100% guilty of losing my temper with AI, daily.

Cursor Rules ... Need help please ..?

Support Help

michaelito80us (Michael E) March 20, 2025, 6:37pm 2

I just wrote a post about rules

https://forum.cursor.com/t/my-take-on-cursor-rules/67535

Topic		Replies	Views
Ultimate Rule Generator - No more failure to generate and Private Rules! Built for Cursor	35	8909	April 12, 2025
Rules for ultra context, memories, lessons, scratchpad with plan and act modes Built for Cursor	47	10403	March 27, 2025
Community tips & tricks Discussions	4	1283	February 16, 2026
Getting started tip Discussions	10	1012	April 4, 2025
Collection help create rules and .cursorrules Guides	1	545	January 16, 2025

Cursor Rules ... Need help please ..?

Related topics