The Perfect Cursor AI Workflow (3 Simple Steps)

Key Concepts:

• Context Engineering
• Spec-Driven Development
• Command Prompts (Create Brief, Plan Feature, Code Review)
• Cursor Rules File
• Starter Kits (Create Next App, Create Vololo App)
• Feature Planning and Implementation Phases
• Automated Code Review
• Manual Testing
• Code Scanning (Security, Performance, Code Quality)
• Vibe Scan

1. Project Setup and Initialization

• Goal: To establish a consistent and efficient coding environment using AI tools.
• Command Prompts: Saved prompts for repeated use in Cursor, categorized for creating a project brief, planning features, and reviewing code.
• Cursor Rules File: A configuration file that dictates technical guidelines for Cursor in every chat, ensuring consistency.
  • Example: Specifying technologies used (e.g., Next.js, Tailwind CSS), commands for installing packages, and preferred coding style (functional programming).
• Starter Kits: Using pre-configured starter kits like create-next-app or create-volo-app to avoid initial setup hassles.
  • Example: npx create-volo-app . sets up a full-stack project with authentication and a database.
• Product Brief: A document providing context to Cursor about the project's goals, target audience, and key features.
  • Example: "We are building an application to help dungeon masters plan their D&D campaigns and it's going to be called Dragon Roll. It will include a variety of different tools such as a random map generator, NPC generator, loot generator, and so on. We will use AI and allow the dungeon master to input certain prompts or use the tools directly."

2. Feature Development Workflow

• Goal: To efficiently plan, implement, review, and test new features using AI assistance.
• Plan Feature Command: Used to generate a detailed technical plan for implementing a specific feature.
  • Example: "We want to add a new page that is going to be our NPC generator. To implement this, we are going to use the OpenAI API to generate the description of the NPC as well as a name. And we'll also generate an image for the NPC using the OpenAI GPT image one model."
• Plan Review: A critical phase where the generated plan is thoroughly reviewed and iterated upon to ensure alignment with project goals.
  • Emphasis on spending significant time (half of the development time) reviewing and refining the plan.
• Implementation Phase: Cursor implements the plan, generating code and modifying files as needed.
  • For complex features, breaking down the implementation into phases (data layer, backend, frontend) for parallel development.
• Code Review Command: An automated code review process to identify common issues, bugs, and deviations from the original plan.
  • Example: The code review checks for discrepancies between the planned image generation model (GPT image one) and the implemented one (dolly 3).
• Manual Testing: Testing the implemented feature in the application to identify bugs and errors.
  • Pasting error logs into Cursor for debugging and fixing.
• Code Review (Manual): Reviewing the code using the review document as a roadmap and Cursor's navigation tools.

3. Example: Building an NPC Generator

• Project: Dragon Roll, a D&D campaign planning application.
• Feature: NPC Generator.
• Steps:
  1. Using the plan feature command to create a plan for the NPC generator.
  2. Reviewing the plan and correcting the image generation model to GPT image one.
  3. Implementing the plan using Cursor.
  4. Running an automated code review to identify issues.
  5. Fixing identified issues, including OpenAI API integration errors.
  6. Manual testing to ensure the NPC generator works as expected.
  7. Iterating on the feature based on testing results.

4. Code Scanning with Vibe Scan

• Goal: To ensure code quality, security, and performance.
• Vibe Scan: A tool used to scan the codebase for security vulnerabilities, code quality issues, and performance bottlenecks.
  • Example: Identifying a default PostgreSQL URL in the code.
• Autofix Feature: Automatically generates pull requests to fix identified issues.
  • Example: Vibe Scan's autofix feature creates a pull request to address the default PostgreSQL URL issue.

5. Key Arguments and Perspectives

• Context Engineering and Spec-Driven Development: The core of the workflow, but simplified for practical use.
• Importance of Plan Review: Emphasizes the critical role of thorough plan review in ensuring successful feature implementation.
• Balancing AI Assistance and Manual Oversight: Finding a sweet spot between relying on AI and maintaining control over the development process.
• Iterative Development: The workflow supports iterative development, allowing for modifications and additions outside the original plan.

6. Notable Quotes

• "If that's the way that you're coding with AI, I got to tell you, there is a better way."
• "I found this to be the sweet spot between just winging it in the chat or doing way too much planning."

7. Technical Terms and Concepts

• Context Engineering: Providing AI with sufficient context to understand the project and its goals.
• Spec-Driven Development: Developing software based on a detailed specification or plan.
• Cursor Rules File: A configuration file that dictates technical guidelines for Cursor.
• Starter Kit: A pre-configured project template that provides a foundation for development.
• NPX: Node Package Execute, a command-line tool for running Node.js packages.
• OpenAI API: An API for accessing OpenAI's AI models.
• GPT Image One Model: OpenAI's image generation model.
• Dolly 3: Another image generation model.
• Vibe Scan: A code scanning tool for security, performance, and code quality.

8. Logical Connections

• The workflow starts with project setup and initialization, which provides the foundation for feature development.
• Feature development involves planning, implementation, review, and testing, forming an iterative cycle.
• Code scanning with Vibe Scan is the final step to ensure code quality and security before deployment.

9. Synthesis/Conclusion

The presented workflow offers a balanced approach to AI-assisted coding, combining context engineering, spec-driven development, and manual oversight. By using command prompts, a Cursor rules file, and starter kits, developers can establish a consistent and efficient coding environment. The iterative feature development process, which includes planning, implementation, automated code review, and manual testing, ensures high-quality code. Finally, code scanning with Vibe Scan provides an extra layer of security and peace of mind. The key takeaway is that this workflow strikes a sweet spot between over-reliance on AI and excessive manual planning, enabling developers to build high-quality applications efficiently.