Cursor, Cody, Copilot: An Honest Comparison After 6 Months of React Work

Last April, around two in the morning, I was staring blankly at my screen while refactoring a complex compound component pattern. Type inference was getting tangled where state was being passed down via the Context API, and I couldn't untangle the structure where four child components were passing intertwined props back and forth. The code that Copilot suggested through autocomplete turned out to be surprisingly clean, and the simple curiosity of "Can other tools do this too?" was the start of a six-month experiment.

I ran all three tools on paid plans. Copilot Individual, Cursor Pro, Cody Pro. The combined monthly cost was roughly ₹4,000. I didn't use all three simultaneously. I switched my primary tool every two months and applied them to the same types of tasks.

When autocomplete shines and when it falls apart

Copilot is strong with repetitive patterns. When creating multiple styled-components of similar form or listing out props interfaces, I barely had to type anything myself. But when dealing with useEffect dependency arrays inside custom hooks, it had a habit of sneaking in variables that shouldn't be there. The build would pass, but you'd end up with infinite re-renders. After getting burned twice, I started always writing dependency arrays by hand.

Cursor's core strength is chat-based code modification rather than autocomplete. With a file open, if you type "optimise the rendering in this component," it shows you everything from wrapping with React.memo to applying useMemo in diff format. It genuinely saved me a lot of time. However, it had limitations in grasping the full project context. There were quite a few cases where it ignored custom types defined in other files and filled them in with any.

Cody touts codebase indexing as its strength, and true to that, it gave the most accurate answers to questions like "Where is this function being used?" in large monorepos. The project I'm working on is a monorepo with six packages, and Cody was clearly ahead when it came to tracking cross-file references. On the other hand, its code generation quality was the most inconsistent of the three. When suggesting JSX structures, it had a habit of dropping closing tags or using index as the key inside map callbacks.

Tasks that actually saved time, and tasks that ate up even more

The biggest time saver was writing test code. When writing unit tests based on React Testing Library, all three tools produced fairly usable first drafts. Cursor in particular was good at following the patterns of existing test files. I was impressed by how it matched the render, screen.getByRole, fireEvent sequence to my style.

What actually ate up more time was the process of verifying the code the tools generated. Because of my detail-obsessed personality, I read every single line of AI-generated code. Sometimes that ends up taking longer than writing it myself. That's not a tool problem, that's a me problem.

So how am I using them now

Six months later, I'm not keeping all three. I've settled on Cursor as my primary tool with Copilot running as a supplement. I only pull out Cody occasionally when I need monorepo code navigation. Regardless of which tool I use, I always manually check useEffect dependency arrays and type definitions in the generated code. That habit hasn't changed in six months, and I don't think it ever will.

October in Pune is when the monsoon ends and the breeze turns cool. These days, I do my code reviews on the balcony in that breeze. On one side of the screen is the diff the AI suggested, and on the other is the diff I revised. The time I spend comparing the two is the quietest and most productive part of my development routine.