I'm a staff software engineer doing a mix of front-end and back-end with emphasis on front-end.

I use both Cursor on Claude 3.7 and ChatGPT on 4o/o3. Cursor seems kind of "dumb" compared to 4o, but it's a good workhorse.

I let Cursor handle the basics - basically acting as a glorified multi-file autocomplete. I think through common problems with 4o, tough problems with o3, I copy all of Svelte's docs into 4o (https://svelte-llm.khromov.se/) to get good Svelte 5-focused feedback, I have 4o code-review what Cursor writes from time to time, I have 4o, sometimes o3, generate "precise" prompts that I'll give to Cursor when me talking off-the-cuff to Cursor doesn't get good results after a few attempts.

I don't consider myself an expert in these areas yet so I might be misusing Cursor, or not making enough use of its rules system, or something. I feel like I get good value for my ChatGPT subscription. I don't feel like I get good value for my Cursor subscription, but I also still feel like keeping it because $20 to type a lot less is still pretty nice. I would be upset if I only had a Cursor subscription and no access to ChatGPT. I am pretty hesitant to pay for AI à la carte. I feel much better about working within the limitations of a known subscription cost.

>I let Cursor handle the basics - basically acting as a glorified multi-file autocomplete.

Same experience. I'm in no need to let the AI write large, real working code. But it's amazing for fast refactoring, function signatures, boilerplate, etc. The real boring parts. I only wish it wouldn't be so eager to try to dump a 50 lines of bullshit code every time. But for small changes, super cool.

Can you please elaborate on how you're copying Svelte's docs into 4o?

I just download the Svelte + SvelteKit (Recommended - LLM Distilled) file from the link mentioned in my original comment and drag-and-drop upload it into the chat context when I'm talking to 4o about coding. Nothing magical. It takes a second to read through the document, but then the LLM works significantly better. It stops suggesting invalid Svelte 4 syntax and prioritizes using Runes.

> Cursor seems kind of "dumb" compared to 4o

What do you mean by that? You can use 4o model in Cursor?

I think part of the reason is, ChatGPT has additional system prompt in chat, API doesn't have.

even if both companies use same model (OpenAI and Cursor), system prompt has a huge impact on results

Cursor tries to save more money on context than ChatGPT. So when both are targeting GPT 4o, the ChatGPT App will incorporate more context history and memories than Cursor.

Cursor lists a large number of models out of the box, and you can select which one you want it to use. https://docs.cursor.com/settings/models

I'm SO surprised to not see aider-chat everywhere mentionned.

I've been using it for about a year and it's incredible.

My take is that most people did not invest the little time necessary to get acustomed to its workflow.

My advices for aider are:

- familiarize yourself with the chat modes (architect, code, ask)

- familiarize yourself with the edit modes (diff, whole, etc) and know which to use for a given model. Indeed not all models handle all modes equally well.

- make the code one feature at a time, by small chunks if needed, by limiting the contxt to the relevant files.

- practice to learn how to best phrase stuff.

- write you coding preferences into aider convention files. Things like "always use type hints, beartype for type checking, python click for the cli, add many comments".

I'm mainly doing python and with proper comments and type hints it's really easy for models to write code that works with the rest of the repo even with only a few files in its context.

Same here, I'd even say you made the learning curve sound worse than it is, no offence :)

This is my workflow for 90% of tasks:

1) /ask: I want to do X. / How would you do X? / What options do I have for X?

2) (optional) /ask>: make these adaptations / consider this / follow up question.

3) "go ahead" (this defaults to /code mode)

For a model I like the style of Sonnet3.7 best.

One caveat: I add my files manually. Knowing what you want and where you want it is 90% of the game and this is where LLMs usually get it wrong.

Aider is to other AI tools what Vim/Neovim is to other IDEs. Super powerful, but with a learning curve most folks don’t want to climb.

https://github.com/hotovo/aider-desk is a gui, takes 5 mins to install, has MCP support (try context7). Definitely worth a look and is an "easy" way in to aider.

Do you find that the time you spend splitting a feature up into small chunks and explaining each small chunk to the LLM takes longer than just writing the code yourself?

I've used aider but found just pounding out some code in neovim to be faster. Perhaps I'm not using aider correctly.

I do think that it can take maybe a little more time with aider but this time investment pays itself off as soon as there is some complexification or issue that LLMs can't fix.

See, if you have no idea of what kind of architecture was used for the passed 150 commits, it will take more time to debug or see if a given new featufe you have in mind is doable without major refactoring for example.

This will probably matter less as LLMs grow more powerful I admit

This is exactly how I use agent mode in Cursor. I’ve never understood why I would use aider. Am I missing something else?

Possibly: I'm a neovim person and barely leave the terminal. So naturally aider fits perfectly into my setup. There are even neovim plugin for having aider directly in it.

That said, I don't get why people are fine switching their IDE to cursor. Lile, if you're in an IDE it's because it has features you want that others didn't. So either cursor does not have them or if it does then you have to configure the whole cursor IDE to work like your original IDE.

In total you've either lost features or been captured into a new walled garden. And lost some time in the process.

Aider's use of litellm makes it 5s change to switch to the latest models. And it's always up to date thanks to uvx.

No really I don't get why people are not using aider more.

Plus the dev is lovely, responsive and helpful.

Cursor is a VS Code fork. Anyone coming from VS Code, one of the most popular editors in the ecosystem, will immediately be comfortable. The full marketplace of extensions is compatible. The switchover is effectively seamless besides a handful of keyboard shortcuts used for the new AI features.

I settled on gptel, which is an LLM package for Emacs. It's kind of a mix of both approaches:

1. You have chats right there in the editor, easy to copy/paste and manage context/history without switching to a browser. You can also quickly add files or portions of files to the context or remove them again.

2. You can choose which model you want to use for what, granted you have an API key.

3. You can quickly highlight some code and ask for a change to it, which along with managed context is powerful.

I tried auto complete again and again but it doesn't work for me. At first I think "yeah, that's what I wanted to write", and then I have to look closer to realise it's not, and that completely breaks my flow and concentration. I can always write some pseudo code and proactively convert it to real code, I like to be in the driver seat.

Context management is really central to my workflow, I manage it like a hawk. Models tend to deteriorate as context content increases, in my experience, so I really try to keep it narrow.

For that reason, and because our clients didn't sign up for their code to be sent to Anthropic et al, I _mostly_ use models like I would use StackOverflow, not to generate non-trivial code I'd actually use.

But having the chats in my editor is really invaluable for me. Powerful text wrangling features make a difference in both speed and motivation.

I use it pretty heavily with pretty much only the high-end models and pay about $15 per month.

FWIW I have been using gptel with local inference by a deepcoder 14b q6 and llama.cpp and it’s not too bad. But it can’t handle big asks. 24GB of VRAM is not enough to make local inference smart enough to be really useful. It’s okayish at things like writing commit messages or reformatting / refactoring local regions of code. 32B quants are slow and not that much better.

have you tried aider? Using it with magit to see the changes is a good workflow. the aider integrations to emacs are also worth it, you can easily add/remove files and send highlighted parts of your buffer.

Do you use aidermacs or something else?

Not yet, but I'm intrigued! Good to know there's good Emacs integration.

I'm the same boat. I came to Gemini after using curosr and Claude code. The latter are touted for their auto complete. But frankly the copy paste has not been the context-switch-nightmare I was worrying about. Best analogy I can think of is with Claude I am playing chess (doing local code completion) where as with Gemini I'm playing Go. Getting concept and large blocks of design patterns (and actually working at that) at time. So since I'm thinking at a much higher level the copy paste is hardly an issue (for me).

Oh frequent checkpointing etc are still key.

I don't use IDEs to begin with. I use a text editor, since I am a UNIX man. So, I don't even have a reason to look at the "AI" flavor of an IDE. The closest thing to an AI IDE that I have tried out were tools like AIDER and Jack's "goose" agent. Neither of those specialized tools has been satisfactory. They all performed worse than just the LLM IMO. I am sticking to crafting my own context that I supply to the LLM. Tools like Simon W's `llm` tool help A LOT to be more efficient at using LLMs in a daily setting.

I'm mostly on the same page, but jumping into a new project with a not-so-familiar language has been made much less painful with Cursor. Regular anthropic chats spew nonsense most of the time and are disappointing, but Cursor really seems to be useful.

Of course it also gets stuff wrong and everything needs to be properly validated, but it's a nice tool to try out.

I didn't know Unix users were not able to use IDEs. The more you know /s

Edit : Sarcastic

I don't know about Unix users, but perhaps, instead, it is they are able to not use IDEs.

I like to laugh at myself a lot but this made me really giggle. Well phrased!

Not true and if only then by choice.

VSCode/Cursor run natively under Linux.

It obviously wasn't obvious enough but I was being sarcastic. My fault anyway, pre coffee.

Fair enough... Honestly, I wasn't using Cursor for a long time because I thought that, as a MS project, it wouldn't be available on Linux.

I use VS Code on Fedora Silverblue.

My current favorite (and free) workflow:

1. Drop project files into https://files2prompt.com to copy a prompt with all file contents

2. Paste into https://aistudio.google.com/ and set a low (or 0) temperature and low top_p

Since Gemini 2.5 Pro is free in AI Studio at the moment, and there's a 1M token limit, this works for most things I need. Cursor is better in some cases where I need a bunch of small edits across a bunch of different files.

Just curious, why change the temp to 0

I've found that to be best for coding, especially when you're describing the exact behavior you want implemented. Plus the format it returns is very consistent (not the case in the various chat UIs).

You don’t want the model to stray or become too inventive when coding.

I use Claude Code (cli tool) and it's on another level. Not even comparable to code autocomplete à la Copilot or copy/pasting into a LLM chat app. It knows about your whole code base, can use external tools, read documentation, run tests, etc. Even as an experienced developer, it's been a huge productivity boost. The main downside is that it can quickly get expensive.

You get the same experience inside VS Code with Copilot these days, as long as you select agent mode. Yesterday I even asked it to read documentation off a URL and it asked me permission to fetch the page, summarized it, and applied the API changes needed.

Does it really know about the whole codebase? How big are we talking about? Last I tried, some time ago, llm didn't work very well "in the large". But I have never tried Claude Code.

No it doesn’t, it tries to be smart about how it loads context that it thinks it needs to perform a task. In reality, in a large codebase I’ve found manual supplying the exact context to Aider with Anthropic’s models to work better.

Same. It's usually very good at generating greenfield projects from scratch, but once you get going you have to manually provide all context to get good results.

I have tried claude code on a few different size code bases and so far very impressed. The code it generates is usually in the same fashion and tone as the rest of the code base.

I guess I should have said that it has access to all your code. But I think it tries to be smart about which files it reads depending on the task at hand.

Claude Code is by far the most expensive tool I used so far. I generally use it for fronted stuff since it's wonderful there !

I've been using Windsurf for a few weeks. I'm a novice programmer trying to build a web app using React and NextJS.

The "context-in-the-codebase" thing for AI-based IDEsis overrated IMO. To extract the most from it, you have to remember to @mention the files.

If you don't remember to @mention specific files, the agent simply tries to perform searches (i.e., it has access to that tool) on the files and folders until it gets some results... and will usually keep broadening the search until it does.

It works well enough I suppose. But I still find myself beginning new chats (for example, per feature) because the model still loses its place, and with all the code/lint fixes it does, it starts to lose context.

Then you're right back having to @mention more files to ensure the model knows how to structure your front end, back end, etc.

(Please excuse any misnamed development terms.) :-)

In VS Code, you automatically get the current file context and you can add all open files, specific files, etc. just before you hit send.

I don't think you're quite right about this, as I've noticed (at least in Cursor) that appropriate context tends to be pulled in automatically.

What I do notice is that the AI systems seem to forget to pull in a lot of context as the project size grows. It's almost as if there's something of a limit to the amount of input data, either to manage costs or compute cycles or something like that.

When I start "vibecoding" it goes really well in the beginning but then when the project grows in complexity, asking it to do something relatively simple falls apart as the AI "forgets" to do that really simple thing in every applicable place (e.g., removing a feature that is no longer needed).

I rolled out Claude Code and Cursor to my whole company. They’re really much better than copy paste. And very affordable compared to professional developer wages.

Wrote about it: https://ghiculescu.substack.com/p/nobody-codes-here-anymore

I'm relatively ignorant in this respect, but how do you "roll out Cursor"? Does that mean developers must now switch to using the Cursor IDE? That's quite an ask. I really don't think I'd like having to switch IDEs at this point.

We didn’t mandate it. We just told everyone they can buy if they want to.

I've finally settled on this:

- A custom vscode plugin to help me copy file contents from the tree view, along with file paths

- A chat based ide (LibreChat, but anything will do)

- An agent that syncs code back, once I'm happy with the conversation (https://github.com/codespin-ai/codebox)

Sometimes I add the agent right at the beginning. Sometimes I do that when I feel the code is ready to be written back. Another thing with the codebox agent is that it lets the agent run unit tests (even inside a docker compose environment, if you want integration tests); so in some cases it can be fire-and-forget.

Why use an external tool if you now have agent mode in VS Code?

How "easy" is it is to scaffold a personal vscode plugin?

Not that trivial to hand code, I just had this feature (copying) in another larger plugin I wrote.

However, I think it can be "vibe coded"these days.

Thanks, overall I should make something like that, but generally optimistic that vscode will soon provide all that's necessary, so laziness prevails.

I use copilot through VSCode. The copilot plugin lets me either ask questions or ask for edits to my code. I can choose which files to include as an additional context to the prompt. I can additionally choose which model to use. Some models are unlimited, others have some monthly quota. GPT-4o is unlimited and quite good with short tasks.

It has also shortcuts for instance fixing errors in the code by just selecting "fix with copilot". Its a bit hit or miss but for simple things work well.

It is very good and seamless. Cannot think of ever copy pasting multiple files of code to some web chats and back.

I think the Coplit plugin is probably the closest thing to an AI IDE that actually works. As per my other comment, I don't actually use any IDE to begin with, but one of my coworkers who uses VSCode has been very fond of the latest iteration of the Copilot plugin.

From your description of how this plugin works, I see why it works so well. It is basically just focusing on the essentials (populating the appropriate context) and then does as best as it can to get out of the way ( <- this part is really important I think)

But you aren't just asking for edits to your code, right? Copilot will actively suggest code completion as you type. This is the real benefit over chat as it's like pair programming.

That, and the way it generates commit comments, I don't think I will write another commit message even again.

The first paragraph implies that they are. I’m doing the same, works really well for writing new code or refactoring. Then polish it up by pointing out bad parts in the chat. At the end I step in and do some manual polish.

I use VS Code too and in agent mode I can say things like “move the database querias into a new module called models.py and convert the SQL into SQLModel classes”. It’s pretty awesome to do chores.

Related to this. ChatGPT, a lot of times provides “bare” diffs (ie. not complete unified diffs - they lack proper headers and line numbers)

They are a pain to apply manually. I’ve tried several visual studio code extensions that apply patches from clipboard or provide an input for it, even saving them to a file and running command line tools - but they all fail

Anyone has a good system, extension or application to easily copy these diffs from ChatGPT and apply them to the code on visual studio (or some other editor)?

Aider is basically asking for diffs and applying them automatically

I mainly use chat(GPT). I used copilot's free tier for a while. For making a quick low effort webpage with some nice styling it worked well. Probably better than chat, since it could touch all css, html and JS that are sprinkled around in different files. But that's not my main job. Overall, I think my work is mainly "deep" problem solving. I don't necessarily produce much code per day. The chat is a helpful aid for thinking, copilot not as much.

Another thing I've noticed is that writing the code myself has often a net longterm benefit. For a while I was generating all kinds of python scripts for converting data between formats etc. I'm not good with python, but LLMs are, so I just used that. Until I ran into a wall too many times. Eventually every "temporary script" kept growing until LLMs could no longer provide what I wanted, and then I was stuck. I would have to go through the whole code from start and internalize it fully to be able to get the thing done. I would have saved time doing it myself from the start. So now I mainly use the chat just to ask about available functions, syntax, etc, but rarely use the generated code. IDEs are not great for this kind of approach in my experience.

> The issue with Copilot is that it's not as smart as the "thinking" chat apps.

Upgrade to a paid plan and you can use many of the same “thinking” models.

Honestly, your entire question is best answered by signing up for a free trial of one of these tools and using it. Not the free tier, a trial or a paid plan.

Copy and pasting into another app is extremely inefficient. You really need to try a tool that integrates your model of choice into the editor.

Here's something that i made which helps me out on a daily basis for the IDEA platform.

https://plugins.jetbrains.com/plugin/26658-contextbuilder

> ContextBuilder is a plugin that lets you combine and manage code files for AI prompts or other tooling. Features include a tool window with the same UI as the old ContextHistoryDialog, filetype exclusions, and a history manager.

You're able to select a directory, multiple directories, a file, multiple files and or a combination of them. After determining your selection, Right Click in the Project Explorer and you'll see "Generate Context".

What about projects where secrecy matters? How do hedge funds use these? Are you comfortable feeding the secret sauce to Cursor?

Code is nowhere near as valuable as most people imagine....

I'd day that hedge funds and quant trading firms are an exception to this rule. If you get access to their model training code, order execution code, and especially their trading strategies, then that is literally valuable since you'd be able to replicate their success.

This is unlike most other companies, say Spotify, where if you get access to their source, there's still not much that you can do with it.

No, code becomes less valuable with the passage of time.

It is in some projects, OP gave a good example: hedge funds.

self hosting via litellm or olama isn't as hard as you think. If you have company kind of money it shouldn't be a problem.

Usually if I want to code a ticket, I'll plan the components out into a TODO list, put some focus music on, and try and enter a flow state where I can stream through the code. Using these AI autocompletes really breaks up that flow for me. So I don't really like the autocomplete stuff.

I have found Cursor sort of useful for aiding in refactors, where I need to e.g. refactor dozens of function calls to move to a new generic function or something. So stuff where it is more than just a find and replace. I've also used it a bit for programming languages I'm not familiar with, though I feel it hinders my learning of the language so I try to avoid that.

I use chat based stuff also to do these Input -> ? -> Output kind of things for data conversion or refactorings, I also use it a lot for generating more involved SQL (which I'm not very good at).

Try asking aider or Cursor to read the TODO and work on the items there, then ask it to update a SPEC.md file (which you can also use for context/input). That workflow has been very productive for me in VS Code with agent mode.

I'm using JetBrains w/ GitHub CoPilot, the amount of context it has around what I'm working on is next level, it's not just 'code complete' but it's 'context aware' as well, say for example I need to open a csv and parse out a few columns by the time I have named the file it's giving me the entire block of code WITH the proper column names of the files, all you do is hit tab and refactor. You won't get that just w/ copy/paste.

I do prefer AI IDEs since they are easier to use, and most of them have agenetic mode so they automatically add relevant files to the context.

But sometimes, when I'm brainstorming ideas, planning a big feature, or thinking about an architecture change, I use a script to compress my codebase into one text file. I upload that to ChatGPT (usually O3 or O1 Pro) to ask theoretical questions, not to get it to write code.

I've been trying out Windsurf for the past two weeks with VS Code and I find it (and Copilot) very helpful, but also very annoying. Occasionally, the windsurf command overlays (explain, accept, etc...) will get stuck and make it impossible to see the code until I restart VS Code. But the biggest problem that I have is with automatic auto-complete. With both Windsurf and copilot, I have trouble figuring out when / if an autocompleted function or line of code will be accepted or generated. I'm still trying to figure out a good way to integrate my coding style with the tools, but I'm still trying because the work has been impressive thus far.

I'm now also trying the same with with Claude-code, which has been pretty useful too. It managed to figure out and explain a fairly technical code base (a few DNA processing algorithms). I haven't tried with with code I'm unfamiliar with yet.

So, my verdict so far: well worth the effort to try it and learn what's available. It's not that expensive to try. If it can help automate somethings (documentation and tests, for example), that's what I'm really hoping to use the AI assistants for. It works for actual coding too, but I still prefer to provide the main foundation.

One thing about a chat interface is you have to be pretty intentional about what you put in the context.

For complex stuff I get it ready in an editor and then paste it in, not ideal I know - but it gets results.

I built a tool that helps with copy pasting code into chat UI called 16x Prompt.

https://prompt.16x.engineer/

It is used by quite a lot of people. So the problem is definitely there.

The app supports API integration as well. From usage stats, still there are more people using the copy pasting flow instead of API flow.

I suspect it is because people are already have a subscription so they can basically use that for free, versus via API where they have to pay.

With that said, Cursor's $20/month unlimited usage is really too good to miss. I will wait for it to end soon.

I use 16x for the copy-paste workflow. Really useful tool. Thanks.

I use cline + Anthropic and Google models with a custom .clinerules for frontend react + typescript. I manually tag relevant files into context

- Gemini 2.5 pro tries to fix and refactor my entire codebase unless I aggressively constrain it, which is too much work. I've written it off as unusable for coding, but can be fine for educational purposes

- For AI IDE coding, I narrow down the scope of what I ask so Gemini 2.0 Flash or Haiku can handle it. I've haven't seen better results switching to paid models.

- For generating large swaths of code, I recently went back to copy/pasting into Claude Projects, with my github project hooked up and relevant files added to context. For a moderately complex component, it usually takes 5-15 generated versions to work, though I end up adjusting my specs a bit in the process. This is still faster than using the agent. Claude Code might get similar results, but I already pay for Anthropic so haven't tried it out.

- If I'm picking up a new library, concept, or pattern, I usually chat with Claude to level up my knowledge. The "Plan" mode in cline focuses more on task execution than skill development.

I'm open to suggestions on what to try next!

To answer your question directly "it depends". There are a lot of different subtasks to coding. Defining requirements, sketching/discussing architecture, coming up with a technical plan, executing it, creating tests, etc. Different interfaces are better at different things. Cursor/Windsurf agentic flows can be great at well defined tasks that are directly actionable within the abstractions of the existing codebase. If you want to build new things, you need to be a little more methodical, and this can mean using chat interfaces to have a dialogue with AI.

I use RepoPrompt [0] + Cursor Tab Complete (since it's easily the best on the market), but I don't use the in-IDE cursor/windsurf agentic flows unless I have a small task I need doing where I can describe it perfectly. RepoPrompt is an underhyped context selection tool that includes

- A prompt formatter so you can easily dump it + prompts into chat windows

- A built-in diff format prompt template that gets auto-inserted so you can auto-apply the resulting changes.

- A unique "Chat" mode that's an API frontend for multi-turn conversations with dynamic code context, templated prompting, etc.

- An incredible "delegate edit" feature where the results of your conversation get sent to cheaper/smaller LLMs to actually enact. The cost savings and increase in coherency are unreal. It's not unusual for a single turn to generate something like 50 specific edits across a dozen files that are completely coherent.

Right now my main workflow is to discuss architecture with a context dump + prompt to o3, settle on a solution, build a PRD, give that to 2.5 Pro to create a more granular plan, make edits, then send it back to 2.5 Pro to delegate edits to Flash 2.0/DeepSeekV3/o4-mini. Not unusal to see it produce 20-50 edits across a dozen files with perfect coherency. Any fixups or minor things I do in cursor.

There are also the CLI agentic code tools. I find claude code to be like a more powerful version of the cursor agent flow. They're great for directed tasks that involve a lot of exploration, like understanding how you need to integrate with some submodule on the other side of the codebase.

[0] https://repoprompt.com/

Try Roo code. It has the least "magic" compared to other solutions, down to having no subscription (you plug your own API key and go). It provides full control and visibity of what it does, you see the context window size and the cost of the conversation at all times. This product is the closest to being an honest "automation of what would be manual copying and pasting" and is a great way to explore the possibilities.

I've gone through a few AI IDEs / agents and CLI tools now, currently on Cline with Gemini 2.5 Pro which is doing a pretty good job at my web app code with a decent .clinerules file in the repo.

To answer why I don't use chat at all for coding anymore, some benefits of IDE / CLI agents: Copy pasting into chat apps don't allow for agentic runs (ie run bash commands, edit code, validate with linting / testing before marking task as 'complete'). I can mostly just write my descriptive task (usually with code references if they aren't already there in clinerules / claude.md, etc.) and come back after a short walk or drinking some tea and check the code or just check at runtime to ask it to fix up the code. This is honestly very similar to "waiting for code to compile."

For reference, I've used the following to make production code changes:

- Cursor: which when Claude 3.5 was out seemed to be the best AI IDE, but the changes they've made around agent mode and 3.7 haven't really worked super well for me. Migrated to claude code after 3.7 came out.

- Claude Code: Very good, I generally just ran it in dangerous mode and it could accomplish tasks fairly well. Wrote a decent Claude.md file as well. Only con is that it got expensive quickly. On the order of $3-5 per session which would accomplish a single task.

- Cline with Gemini 2.5 Pro: Moved to it yesterday, it's been doing a good job and is effectively free right now using my own API key for Gemini. Seems a bit verbose at times although that might just be Cline's prompts.

I haven't tried Aider or Windsurf, but have heard good things about Windsurf's agentic mode. Although I might not move to Windsurf at all since Cline with Gemini works pretty well & is free to use.

> is effectively free right now using my own API key for Gemini.

I think the cost is/was a big factor preventing many from switching from Chat-based coding to Cline/Cursor/Aider.

For my hobby projects I don't want to spend 3 USD to get some assistance which I can get for free through a monthly subscription (and some extra pasting).

Google is smart to offer a free use tier on API-usage which seems enough for agentic coding.

Zed strikes a good balance I think with their non-agentic text threads feature. You use slash commands to add whatever you need to the context (single files, directories, highlighted selections, etc) and interact with a conventional chat interface from there. The prompt library also lets you store convenient system prompts if you have a diverse task domain.

You can of course use their new agentic features which can automate a lot of the context management via tool use, but I find that to be a waste of time and resources for the majority of tasks I care about.

I currently manage my own fork to use a custom FIM completion provider I built, that tends to do most of the heavy lifting for me in terms of anything AI-generated.

I use thisismy and thisismy-desktop to combine code - full repos + and specifications as Megaprompts into the LLM - mostly currently Gemini 2.5 Pro as we are talking ~500k tokens

full files, JIRA tickets with is/should, DRY/KISS refactorings and root cause analysis are done this way

full files are usually just copy/pasted, everything else added for cursor as in insttuctions

Cursor does a lot more of the work. It not only tells you what to write, it jumps across different files and makes the edits. It indexes your code and has a good idea how it goes together and where your code is.

They acquired Supermaven last year, which was also one of the fastest code completion with the biggest context window even versus the new models. So they are able to do a lot of quality work locally before involving the major LLMs.

A year's subscription falls at about $16/month. I would say Cursor is the first real use of AI and it gives so much unfair advantage to those who use it. You get quality + speed/stability + low price, there's just little reason to paste anything into websites anymore, and no reason to go back to Copilot.

Been experimenting with Roo-Code in VSCode on Sonnet 3.7, but my daily driver is ChatGTP.

I guess it's mostly because of my usage type, more 'explain these few lines of code' or 'write a short funcion for X' in Python or JS, not the 'create this complete app' I see people using the agentic approaches for.

OpenAI is mostly out of habit and because I have grinded out a high tier because I use it through the api in my production systems. With Anthropic I still run into throtteling, even though it's output seems better in terms of less halucinating.

I've tried every conceivable combo, and I've settled into using GPT o3 (outside of an IDE to do Deep Research on the tech that I am developing an app with first), then taking that context into VS Code (as markdown), and using Claude Code within VS Code to begin generating component files. I typically stay there until I finish the app, with frequent visits to Claude 3.7 Sonnet (on the website) for more creative inspiration and code snippets when Claude Code gets in a rut.

I tried to vibe code a web app with windsurf and found it appeared to do really well in the beginning. But I had to harsh the vibes in two types of scenarios it couldn’t understand or solve on its own: performance and css animation.

When I copy paste via ChatGPT I direct the model on what to do and retain responsibility and understanding of all code getting saved.

I do really like Cascade in windsurf because it does a decent job of parsing the entire codebase and finding the spot to make changes. But I think I’ll probably be most successful combining my approaches and using Cascade at a coding level not a “vibe” level

I've been using cline and RooCode with vscode. It's significantly better than copy pasting. I work in a quite large codebase that has several different areas, and these AI tools are really good when I get a task in an area I'm not very familiar with, they'll perform searches and write a plan telling me where to start. I feel like I would do a similar job, but it can do it faster and will always do a comprehensive search and double check, where I might get lazy and jump in the first place that looks right.

Much more hit and miss for actually writing code. Sometimes it works.

I use Windsurf. I thought I could potentially cancel my ChatGPT subscription after a while but now concluding that that likely isn't possible. Windsurf is good for some things, but can take a lot of prompting and honestly does a lot of dumb stuff. It is also very slow. It can sometimes arrive at a solution faster than you can when very tired but most of the time I feel like I am just being lazy.

That being said, it is worth the price as it can be helpful sometimes. I pay $15 per month and haven't gone over the token limit yet. ChatGPT is still fundamentally more useful however.

If it is a single function or a class I most of the time prefere copy/paste from the chat. If multiple files needs to be updated then there is a lot of convinience with using a AI IDE.

For writting code the old fashion way. You type the code the intellisense/auto-complete build in to the like of cursor AI is the most annoying thing i have ever seen in a IDE. You constantly sitting hitting the escape key try to get their auto-complete suggestion to go away. Most of the time is it guessing where wrong and is mostly useless.

The biggest issue is when you try to use a class that has properties. When you press the dot after the class name normally the IDE will list the public properties on the class.

Now you have to battle that the list now longer contains just the properties found on the class but also non-existing properties invented by the AI IDE. As clever as this AI autocomplete can be, i really hate it because I can no longer rely on that my IDE is telling the truth about what properties and functions there is exist on a class.

and if you are the type of programmer that like to put empty lines in your code for readability. Then moment you hit enter you now get an often completly irrelevnat code suggestion and need to battle that suggestion to go away. I just want an blank line for crying out loud.

PS: my AI IDE is cursor

I definitely agree with the points about empty lines of code and properties on classes. Same problem with Copilot and VSCode.

I used the Jetbrains IntelliJ AI briefly. It's certainly convenient to just click a button and have it fill in documentation or write appropriate tests for the context of the file or like you're on.

I would definitely use it over copy pasting for the convenience. However, I only code as a hobby these days, so probably won't pay for it unless I really get stuck into a larger bit of work - but would definitely then.

My experience with Cursor - it's a great tool to work with websites and may be simpe yet vast app code updates. You have quite a lot of control and diffs are helpful.

For engineering though, it's probably better to spend more money on Claude Code. He will be your super-knowledgeable junior assistant, which will result in much higher efficiency. AIDER is also an option.

The user patterns are a bit different in each case. When I'm copy-pasting from GPT, I'm forced to define the problem better and be specific on the output I'm looking for.

Compared to Cursor with full codebase context where I can get away with less, so I typically fall back to the lazy prompting patterns of "not like that, do better". Which likely eats up more time than had I prompted well to begin with.

I'm not a developer. I use Claude and copy paste which works fine for me. Just picking up on one thing it's not unlimited use, Claude stops working for me after a certain amount of usage and offers me access to the max plan. I also would add that chat based code seems to bloat, the llm will add in a bunch of stuff that's not needed and that ultimately reduces the time it can work on my problems.

There is access to Claude and Gemini inside GitHub Copilot, and they both support agent mode, so I don’t get why you would still use a chat app.

Cursor has a free trial. Give it a try. AI is kinda personal, lots of people benefit, lots of people dislike it for many valid reasons.

VS Code is very quickly catching up to Cursor as well (added tab-driven completions).

Also you don’t have to be right on the edge of things. You can be, or you can wait for the dust to settle. Claude Code / OpenAI Codex and the agent modes are probably the edge now.

Also if you’re still using a terminal (who isn’t), try Warp. It’s improved a ton over the last year, support more niche shells like Fish now. It’s actually a really “fluid” AI chat integration, because it smartly figures out when what you’re typing is not a command but a prompt. (It’s probably also on the edge, I haven’t figured out how to tell it “you’re wrong” when it asks for a permission for example, I have to “cancel” the chat).

I'm still stuck pre "thinking" and pre "web research" features in terms of what I feel works best (vs delay to get a response..).

Very surprised when I asked Cursor to diagram some code, saves me so much time. I wish it would output a better format than ASCII.

I thought Cursor was pointless until trying out Google's latest coding GPT, which blows everything else out of the water. I may switch from VSCode to cursor for the next few months just because of that.

Why not just switch Copilot to use Google Gemini 2.5 Pro as the model?

With every update to the Copilot extension, I see less and less of a need to switch away from VS Code to some “dedicated AI editor du jour”.

Maybe I’m missing something, or maybe people aren’t keeping up with Copilot’s capabilities?

⁽¹⁾ https://code.visualstudio.com/docs/copilot/reference/copilot...

⁽²⁾ https://code.visualstudio.com/docs/copilot/chat/chat-agent-m...

⁽³⁾ https://code.visualstudio.com/docs/copilot/chat/copilot-edit...

Good point. I suppose I'd missed that they added it. Trying it now and it's fantastic.

Do you mean Google Code Assist plugin for IDEs or something else?

I meant the GPT Gemini 2.5 pro exp. but I see now it's available in VS code too. Guess I missed it because I was always using Claude

I wish there was a plugin / cli / TUI that would grab what you are doing and copy it into your clipboard for a chat app. That way I don't need to worry about tokens and usage limits.

There are actually a lot of tools that do this:

https://prompt.16x.engineer/cli-tools

my screen-query tool does this: https://github.com/kristopolous/llmehelp?tab=readme-ov-file#...

You can install it in a few seconds, one line: curl 9ol.es/talker | sh

tell me what you think.

I tried Cursor as I was excited it used Tree Maps for RAG. I tried it for 3 different medium asks on a medium sized project (https://github.com/Kareadita/Kavita).

I was extremely disappointed. It recreated enum files with the same values, tons of changes, overall I rolled back.

I use copy/paste into ChatGPT/Claude a lot. I will stick with that. I control the scope, I control what I copy or how I take the solutions.

I stand by my belief that AI cannot work on medium to large codebases. I know we see vibe coding as a trend, but those are usually greenfield applications.

I do this to copy files into the chat

`cat file.js | xclip -sel clip`

On Linux, this copies the whole file to the clipboard and I can paste it in.

This is considerably faster than using the mouse.

I can also get a code review done by getting the diff `git diff develop..feature/my-branch | xclip -sel clip`

great tips if you want more context, aider has /copy-context that copies the files that you have added to the context, your chat (I think). you can then paste into a subscription chat app where you're not paying per token

They are significantly better! IDEs aren’t just like LLMs; they transform your codebase into embeddings (knowledge), giving them a much greater advantage in understanding larger contexts and effectively acting on the code. Plus, they come with proper tool integrations, allowing them to apply changes seamlessly while including fallback mechanisms to handle any issues during the process.

>they transform your codebase into embeddings (knowledge), giving them a much greater advantage in understanding larger contexts and effectively acting on the code.

Is this true? Isn't the context size controlled by the model? Is there any difference (outside convenience) to pasting your code in the web interface?

Sure thing! They can’t just dump all the code from your repository into the context.

The first step is identifying the relevant code in your repo, likely using an indexed vector database. They probably transform your question or prompt into an embedding as well to enhance accuracy. Once they’ve pinpointed the relevant sections, they send those specific parts of your code to the LLMs for processing. I actually wrote an article diving deeper into this concept—check it out!

https://medium.com/@level09/cursors-secret-sauce-the-embed-t...

I struggle in two places - algorithms and understanding all the possible inputs to make a graph in something like MatPlotLib. I find most of my time is wasted trying to get something like those to work and I can do it easily in cursor with Claude 3.7.

I’m rapidly producing something now, and feel uncomfortable with the leverage I’m giving cursor/claude but I am trying to get it done and come back and refactor.

AI IDEs get in my way. I like copy and paste.

The big secret to success?

JetBrains IDEs have “compare with clipboard” - essential tool to verify what the LLM changed.

I’ve built multiple apps just for myself using the API and honestly it sucked. The chat remembers context and talks to you like a real conversation. The API is crazy expensive and painfully slow. It’s best for one-shot queries where you ask one thing and expect nearly identical results every time. Anything beyond that and it struggles.

With ChatGPT Canvas I’ve completed small projects like WordPress plugins, handy personal Python scripts, chrome extensions (my favorite use of ChatGPT) and most importantly debugged faster than any tool I’ve ever used. Sure, my customer-facing GPT API apps are burning credits like a rocket on full throttle but at least I’m billing them for it. The API speed is wildly inconsistent so you can’t rely on it for everything.

One key tip is you can’t keep a single chat going forever. It gets sluggish, especially when you paste long code blocks. My method is simple. I ask for the final clean code, then request a complete detailed summary of what we built and what the functions do. Then I start a fresh chat, paste the summary and code, and continue clean. Think of it like making a commit, just a very crude version.

I use Chat and Paste with LLMs. I have tried Cursor and Co-Pilot but they both kinda of suck in their own ways. I feel like understanding of the code completely goes away with Cursor since it's doing it's own thing. There's benefits to that but then it is challenging to debug since you don't know about the codebase. With Chat and Paste I think more about what I am putting in my codebase.

I started out trying to use my ChatGPT subscription as you describe, but then migrated to Cursor.

It suits my workflow a lot better because I can reject suggestions easily, or accept partial diffs. I can approve certain chunks but instruct it to rethink other parts if I think they are a bad approach. This isn’t possible if you are just copypasting chunks of code back and forth between an IDE and browser window.

As for the cost, you get 500 “fast” requests per month for Premium models. If you use them up, then you can still use the Premium models, but are placed in a queue so have to wait a bit longer (Cursor refers to these as slow requests). I haven’t been in this situation yet, but I am not a super heavy user.

I find the trick is to give simpler requests to the unmetered models, and save the harder requests for the premium models. You can select the model you want to use in the chat or agent box.

The model list is here : https://docs.cursor.com/settings/models

So, for example, I might give simpler requests that save time or involve boilerplate to Deepseek-v3, gemini-2.5-flash-preview, gpt-4o-mini, or grok3-mini-beta. These are unmetered, so you can use them as much as you like. For requests that are more difficult and require better thought, I would choose something like claude-3.7-sonnet, or gemini-2.5-pro.

For context, I prefer the workflow of using Ask (chat) mode and working on a single file at a time. If I want another file to be considered, I refer to it using the @ convention in Cursor to refer to other sources. Others have complained about Cursor skimping on the context window of requests to control costs, so I follow this approach to make sure that the things I specify are considered. The files referenced remain in the context of the chat, so they are included for followup requests.

I feel that for those of us with programming experience, using it in a discriminating way is the best approach. It might be disconcerting to see people rage about Cursor on Reddit, but there are a lot of Vibe coders on r/cursor with unrealistic expectations. So they might well only use Agentic mode with vague directions, then rage because they burned through all their credits in a weekend, or had the models erase code because they’re unaware of Version Control. Agentic mode can be useful, but I want to at least glance at every diff to make sure things are going in the right direction.

I would suggest the free trial to see if it improves your workflow as much as it did mine. BTW, I find that working in TypeScript is a sweet spot for this, as VSCode and derivatives excel at TS, and when diffs are suggested you get immediate feedback on whether it would break compilation before you’ve even accepted the suggestions.

it's night and day. It's so much more productive because the amount of time needed to ask a question is near zero.