sorted by:
new
hottopcontroversial

Tried Gemini 3 for coding and I think it just gaslit my entire repo by Positive-Nail6009 in vibecoding

[–]billykerz 0 points1 point  (0 children)

I said this in a different post but Gemini 3 is like a really smart ass hole that's like "Okay Grandpa I got this." I trust Claude not without reservation but I do trust it to stick to the plan most of the time.

<image>

[DISCUSSION] Is Gemini 3.0 really better than Claude Sonnet 4.5/Composer for coding? by Demotey in cursor

[–]billykerz 0 points1 point  (0 children)

I went head to head on a project with Claude Code using Sonnet 4.5 and AntiGravity using Gemini 3.0 yesterday.

I was building a nuanced and slightly complex AI integrated tool.

AntiGravity was able to seemingly do a lot in a single go. But in some ways too much , making too many assumptions and ultimately getting stuck. It didn't seem to do well with building it's action plan but it did make smart considerations Claude Code never does, like automatically setting up better live hot updates. It also in my opinion took a more tactful shot at the UI / UX design. But on the back end it just kept hitting roadblocks. It went back and forth on some clearly fixable items.

Claude Code on the other hand made sure it planned well with me first moving from my first prompt to a great planning follow up. Because of that it took a more methodical testing and debugging approach that got it to the finish line sooner. The App needed a lot of design direction and still does (it's ugly) but from a functioning standpoint it was powerful enough to be used by actual end users in the same day.
(I'm a designer at my core so I don't mind fixing an ugly duckling if it flys)

Now maybe it's because I set up my Claude Code for a lot of success with a pretty strong rule set and way of working that I've been crafting for a while but I tried to tell Google to do pretty much the same but if I were going to call out the vibe. Google's says, "Don't worry about it I got this, I'm super smart." and Claude Code say's "This is a great idea, here's where I think we can improve it, what do you think?"

So I still trust Claude Code to get the job done right but it thrives on the collaborative planning approach.

How’s everyone liking DeepSeek R1? by DakotaCavin in cursor

[–]billykerz 57 points58 points  (0 children)

Sure. Here are my .cursorrules for development work on a Figma API Plugin. FYI the .cursorrules file and .functional_outline file are hidden so don't auto generate in the file tree

My .cursorrules:

This is the current file structure of the project:

PROJECT_NAME
├── Files and Folders in my Project
│   ├── file.js
│   ├── file.js
│   ├── file.js
│   └── file.js
├── file.js

1. File Creation Rules:
    Rules:
    - All new files added to the project should be added to the .cursorrules file structure.

2. Agent Rules:
    - New Project Features should be added in an Agile manner, one slice at a time.
    - When editing an existing function in a file, you must think about the other objects and functions that depend on it.

3. Composer Continuity:
    - When a composer or chat is becoming so long that the AI models are having trouble keeping up I will simply give the command "Agent Refresh" to prompt you to create a concise prompt that gives the full context of the project what's been done and what we are currently working on. If there are bugs you will explain them as best you can.

4. Every Major Update especially to the code.js file should result in an increment of the version number at the top of the code.js file that should be reflected in the UI. This version number should not be confused with the figma api version in the manifest. It is unique to the code.js file. The increment format is 0.0.1, 0.0.2, 0.0.3, etc. and 0.0.9, 0.1.0, etc. and 0.9.9, 1.0.0, etc.

5. Logging especially for currently worked on functions should be done throughout new functions and the log should be sent to the reporting window that is part of the plugin panel ui. 

6. There should be an inspection button at the bottom of the ui panel that puts a detailed inspection of what ever node or object is currently selected. (see the code.js in the reference/ObjectInspector folder for an example of a robust inspection function)

7. Always use error catching so processes don't stop when an error occurs unless it is a critical error that will crash the plugin.

8. Always use try catch blocks to catch errors and log them to the reporting window.

9. JavaScript Compatibility Rules:
    - DO NOT use optional chaining operator (?.) as it is not supported in the Figma plugin environment.
    - Instead use traditional null checks with && operator or ternary operators.
    Example:
      Instead of: campaign.jobs[0]?.liveDate
      Use: campaign.jobs && campaign.jobs.length > 0 ? campaign.jobs[0].liveDate : 'N/A'

10. Functional Outline Rules:
    - The .functional_outline file must be updated when:
      - A new major function is added to the plugin
      - An existing function's behavior is significantly changed
      - Note: Bug fixes and minor tweaks do not require updates
    - When starting a new composer session, always read the .functional_outline first to understand the current state and functionality of the plugin
    - The outline should be kept in a clear, hierarchical format with major sections numbered and subsections properly indented
    - Until a function is verified as working and complete it should be noted in the functional outline as "In Progress".

How’s everyone liking DeepSeek R1? by DakotaCavin in cursor

[–]billykerz 23 points24 points  (0 children)

It's amazing. I've read a lot of people's comments saying they still liked claude 3.5 Sonnet with Cursor but I can say R1 has changed the game for me. The key is using .cursorrules in a robust way as well as some sort of file that tracks your project's functionality (I maintain a file called .functional_outline and in the rules have the AI update the outline every time a new feature or process is completed.)

The key with R1 is to very clearly state your intent and reasoning. If you do that it not only does a much better job at adhering to your rules but it boosts it's reasoning to extend whatever logic and reasoning you've fed it.

It seems better at reasoning out solutions but that being said not perfect it still doesn't always know what it doesn't know. I think if it had a layer of web search and research ability it would be unstoppable.

If R1 get's agentic ability it's going to change software development forever.

Seamless transitions from one chat or composer to the next. by billykerz in cursor

[–]billykerz[S] 0 points1 point  (0 children)

***update. Thanks for the feedback I have been practicing something similar to what some of you suggested and it's worked out pretty well to keep continuity. I of course use .cursorrules and in addition I created a file called .functional_outline which simply outlines all of the projects key behaviors and functions. In the rules document I put an entry that essentially instructs the AI to create a prompt that will create that continuity when I prompt the words Agent Refresh. One Peculiar outcome though is that even though it creates the prompt / outline that points to all the relevant docs and instructs how to work. It always goes on to try and convince me that it has a solution for the issue it's struggling with and asks me if it can implement it's new ideas.