Skip to main content

Beginner's Guide to Larger Projects

Introduction​

If you've been using Cursor for a while and started dealing with more complex projects, you've undoubtedly faced challenges in keeping your project on track. This guide shares some practical tips for handling larger projects effectively in Cursor.

Basic Tips​

1. Using Composer​

While the chat feature is suitable for quick questions, Composer provides checkpoint functionality. This allows you to return to a known good state when the project veers off course or takes too long debugging.

2. Using Git Wisely​

Git integration is crucial. Commit frequently - storage is cheap, and checkpoints can save a lot of pain. Don't wait for everything to be perfect to commit; think of commits as comfortable checkpoints rather than milestones.

3. Using Prompts​

Use templates at the start of each Composer session to encourage good programming practices. If you want the model to excel in a particular technique or methodology, make that clear at the beginning of the session.

4. Maintaining a Project Note​

Keep a note describing your goals and specifications and always keep it in your Composer context. This is essential for keeping the model on track and maintaining good momentum throughout the project.

5. Preferring Short Composer Sessions​

Long sessions can lead to UI slowdown and degraded output quality. When you notice the model starting to hallucinate or make circular changes, start a new session. Repaste your prompt, explain the current state, and continue for better results.

6. Always Ask for a Plan​

Follow this format for successful sessions:

  • Include a prompt about AI capabilities
  • Explain high-level system overview
  • Clarify your next goal
  • Request a plan before coding
  • Have AI explain its approach before making changes
  • Regularly review the plan and next steps

7. Embracing Test-Driven Development (TDD)​

Leverage AI to write tests - traditionally this is the tedious part that humans often skip. Start with descriptive tests, use mock implementation, and let the test framework guide your development. This approach helps maintain focus and verify assumptions throughout the project.

Best Practices​

  • Maintain good unit isolation and encapsulation
  • Use interface-driven development
  • Keep clear separation of concerns
  • Create regular checkpoints in Git and Composer
  • Focus on modular design to reduce context requirements

Additional Tips​

Project Organization​

  1. Structure your codebase logically
  2. Keep related files together
  3. Use meaningful file names
  4. Maintain a clear project hierarchy

Documentation​

  1. Write clear comments
  2. Keep README files updated
  3. Document API changes
  4. Maintain a changelog

Version Control​

  1. Use meaningful commit messages
  2. Create feature branches
  3. Review changes before committing
  4. Maintain a clean git history

Testing Strategy​

  1. Write unit tests first
  2. Implement integration tests
  3. Perform end-to-end testing
  4. Automate testing processes

Common Pitfalls to Avoid​

  1. Skipping documentation
  2. Ignoring test coverage
  3. Making large, infrequent commits
  4. Not planning before coding
  5. Keeping long-running sessions

Source​

@https://forum.cursor.com/t/an-idiots-guide-to-bigger-projects/23646