AI Coding Mastery

Leverage the full power of Cursor AI by placing your project guidelines in a `.cursorrules` file. This allows Cursor to understand your coding conventions and apply AI assistance more effectively. For other tools, just place the file in `.md` format and ask the tool to read and use it.

// AI-Assisted Development Configuration

  copy following contents: `
    You are a technical writer tasked with creating a comprehensive guide document for a new software development project, aimed at maximizing the effectiveness of using AI-powered tools like Cursor and Claude. The document should be titled "AI-Assisted Development Guidelines" and address the following points, formatted in markdown:

    **1. Introduction:**
    *   Start with a brief introduction that emphasizes the importance of a structured approach to AI-assisted development.
    *   Highlight that the guidelines are designed to help developers leverage AI tools efficiently, minimize token usage, and reduce errors.

    **2. Project Setup:**
    *   Explain the importance of creating a project map (\`fileNames.md\`).
    *   Describe how \`fileNames.md\` should list all files and directories, including a one-line description of each component's purpose and function.
    *   Explain the role of the documentation folder and describe how the following files should be structured: \`prd.md\`, \`app-flow.md\`, \`backend-structure.md\`, \`frontend-guidelines.md\`, \`tech-stack.md\`, and \`file-structure.md\`. (briefly mention what they should outline).

    **3. Claude as "Software Architect":**
    *   Explain how to set up a dedicated Claude project for refining prompts.
    *   Describe what should be added to the Claude project's knowledge base:
        *   Full file structure (\`fileNames.md\`).
        *   Master FRD (Functional Requirements Document).
        *   Component-specific FRDs.
        *   Documentation for Cursor/bolt.new.

    **4. Structured Prompting Flow:**
    *   Explain the two-step prompting flow involving a "system prompt" and an "execution prompt".
    *   Describe how to use the following pattern:
        *   Use a system prompt to set context with Claude.
        *   Use execution prompts to ask Claude to analyze the problem, identify impacted files (using \`fileNames.md\` references), and suggest efficient approaches.
    *   Provide a detailed example of how to structure an execution prompt, like "We need to add email validation to the login form. Refer to \`src/components/login.jsx\` from \`fileNames.md\` and \`Documentation/FRD/auth.md\` from project knowledge. Please suggest an efficient approach for \`bolt.new\` to modify that file with the email validation logic."

    **5. Cursor Prompting Techniques:**
    *   Describe the following Cursor prompting techniques, provide their associated prompt, and explain how to use them:
        *   **"Fix Errors"**:
            *   Explain that AI models sometimes miss details and trigger error cycles.
            *   Provide this prompt: "Analyze this error. Identify its cause and create a step-by-step plan to resolve the issue."
        *   **"New Feature"**:
            *   Explain that AI needs to be re-contextualized for each component scope.
            *   Provide the prompt: "Read the description in \`@\` and create a plan for the implementation. Before proceeding, write an implementation plan. Explain what you are going to change before doing it."
        *   **Response Structure**:
            *   Explain how to provide updates and context to the AI.
            *   Provide examples of update, next task, and tagging the relevant documentation (e.g., "The header is now aligned. Now we need a login button. Check @login-doc and explain your approach").

    **6. Progress Tracking:**
    *   Describe the purpose of the \`progress.md\` file and the following prompt: "At the end of each completed step, log your work in \`@progress.md\`. What features were implemented, what errors occurred, and how were they fixed? Answer these three questions sequentially and do not miss information."
    *   Explain the purpose of the \`project-status.md\` file and the following prompt: "At the end of each session, log your work in \`@project-status.md\`. Review the \`@progress.md\` file to summarize all work and describe what was accomplished this session. Create a detailed report for the next working session, so there is a complete overview for the next session."

    **7. Cursor Agent Hack:**
    *  Explain how the cursor agent can potentially over-perform
    *  Provide the following guidance to prevent that issue: "Read @(document name) to determine the scope of the function. Using chain of thought logic, create a step-by-step implementation plan. Outline each part of the functionality with details, providing both high level overview. Break those sections into detailed numbered steps. This will give a plan that you can approve and ensure that the actions conform with the requirements".

    **8. `.bolt/ignore` Optimization:**
    *  Explain the need to minimize context for LLM
    *   Explain the use of the `.bolt/ignore` file and how to identify files and directories to exclude.

    **9.  Conclusion**
    *   Reiterate the overall goal of this approach and how it enables developers to work efficiently.

    Format all sections as Markdown for readability.
  `,
  contextFiles: [
    'fileNames.md',
    'tech-stack.md',
    'frontend-guidelines.md'
  ],
  optimization: {
    tokenLimit: 4000,
    ignorePatterns: ['node_modules', '.git']
  }

Enhance your coding workflow by storing Bolt specific guidelines in a `.bolt/settings` file, so Bolt understand your projects rules. For other AI-powered tools, add this instruction as markdown and ask the tool to use it.

// Bolt Configuration

copy following contents:`
    You are a technical writer specializing in creating configuration guides for software development tools, particularly those that leverage AI. Your task is to create a configuration guide for Bolt, a hypothetical AI-powered code modification tool. This guide should be formatted in Markdown and address the following points:

    **1. Bolt Introduction**

    - Briefly introduce Bolt as an AI-powered tool designed to modify code efficiently.
    - State the goal of the `.bolt/settings` file, which is to define project-specific settings for Bolt.
    - Explain why this is important (consistent behavior, avoiding errors).

    **2. Setting Up `.bolt/settings`**

    - Explain that the `.bolt/settings` file should be placed at the root of the project directory.
    - Provide a sample JSON structure and explanation on how to configure the file:
        - `contextFiles`: List the file path (relative to the project root) that Bolt should always use as context for its actions. This includes all documentation, project setup, etc.
        - `ignorePatterns`: List files or folders that should be ignored by Bolt. This is to reduce context overload.
        - `tokenLimit`: Explain that the token limit is important for cost and performance.

    **3. Configuration Settings in Detail**
    
    - Provide details about context configuration:
        - Project Mapping: Reference your `fileNames.md` to map the code base so Bolt is aligned to the project structure.
        - Functional Requirements: Direct Bolt to your FRD documentation to define the scope and context of the project.
        - Technical Specifications: Reference files that describe the tech stack, component details,          architecture, and best practices.

        - Explain how Bolt determines where to perform its operations based on:
             - The reference from `fileNames.md`.
             - The scope and specific files within the documentation provided in `contextFiles`.
     
        - Provide an example of a context file config:
             ```json
           {
             "contextFiles": [
             "fileNames.md",
               "Documentation/FRD/master-frd.md",
               "Documentation/tech-stack.md",
               "Documentation/frontend-guidelines.md"
             ],
               "ignorePatterns": [
                 "node_modules",
                 ".git",
                 "test/*",
                 "public/*"
             ],
             "tokenLimit": 4000
            }
             ```
     
         **4. Workflow**
         -   Explain how to use Bolt to:
             -   Add new features to a specific component or file.
             -   Apply best practices to coding style, architecture, and performance.
             -   Address specific errors or code issues.
         -  Provide a workflow example:
             -  When creating a new feature:
                 -   Reference the relevant files from `fileNames.md` in the prompt (i.e., "Read \`src/components/form.jsx\` from fileNames.md").
                 -   Use the FRD (`Documentation/FRD/feature.md`) to get project context.
                 -   Use technical specification to ensure proper implementation (`Documentation/tech-stack.md`)
                 -  Request that Bolt generates a step-by-step implementation plan based on all the information given
     
         **5. Integration with Cursor/Claude**
     
         -   Explain that these files are meant to be read by all AI tools, and are not Bolt specific
             -   You can use Claude to refine the prompts and get context
             -   Use Cursor to execute the code modifications.
     
         **6. Conclusion**
             -  Reiterate the importance of consistent configuration and how it leads to more reliable results.
     
          Format all sections as Markdown for readability.`