Reading all these glowing reviews of Claude Code, I still get the feeling that either everyone’s been paid off or it’s just the die-hard fans of terminal windows and editors like Emacs and Vim. Using the terminal is right up their alley—it’s in their DNA.
Every time I read comments saying Claude Code is far better than Cursor, I fire it up, pay for a subscription, and run it on a large, complex TypeScript codebase. First, the whole process takes a hell of a lot of time. Second, the learning curve is steep: you have to work through the terminal and type commands.
And the outcome is exactly the same as with the Claude that’s built into Cursor—only slower, less clear, and the generated code is harder to review afterward. I don’t know… At this point my only impression is that all those influencers in the comments are either sponsored, or they’ve already shelled out their $200 and are now defending their choice. Or they simply haven’t used Cursor enough to figure out how to get the most out of it.
I still can’t see any real advantage to Claude Code, other than supposedly higher limits. I don’t get it. I’ve already paid for Claude Code, and I’m also paying for Cursor Pro, which is another $200, but I’m more productive with Cursor so far.
I’ve been programming for 18 years, write a ton of code every single day, and I can say Cursor gives me more. I switch between Gemini 2.5 Pro—when I need to handle tasks with a big, long context—and Claude 4.0 for routine stuff.
So no one has convinced me yet, and I haven’t seen any other benefit. Maybe later… I don’t know.
I think it’s because a lot of people deeply misunderstand what the hard parts of software development actually are. Most of the time, programs won’t involve novel or complicated algorithms or whatnot. It’s mostly just gluing ideas together. But that all comes after the specification, design, architecture, planning, etc.
I think it can also be deceptive the same way it can be in basically any trade: it’s easy for the job to get “done” and work. It’s hard to do it properly in a way that it has a lasting durability. With A.I. we can spit out these programs that work and look done. And for prototypes or throwaways and such, that’s probably wonderful! But that’s not going to fly if you’re building a house to spec for people who are going to live in it for 30 years.
Yeah, writing code has been near trivial since I started working 12 years ago. Used Intellij since 2012. The difficult part was always reading old code and figure out the boundaries where backward comparibility breaks and figure out how to execute a rollout safely.
>it’s easy for the job to get “done” and work. It’s hard to do it properly in a way that it has a lasting durability. With A.I. we can spit out these programs that work and look done. And for prototypes or throwaways and such, that’s probably wonderful! But that’s not going to fly if you’re building a house to spec for people who are going to live in it for 30 years.
Let’s be honest, that’s what most companies pay good salaries for most software developers for.
When staring at a new job or project, do you more find yourself praising the architecture and quality? Or wondering how it got to this point?
I used to feel similarly. But recently started using Claude Code and it does feel a lot better than Cursor for me
I'm not sure why. However, Claude does seem to know better where things are and knows not to make unnecessary changes. I still need to guide it and tell it to do things differently some times, but it feels like it's a lot more effective
Personally, I also like that usually it just presents to me only one change/file at a time, so it's easier for me to review. Cursor might open several files at once, each with a tons of changes, which makes it a lot harder for me to understand quickly
Btw, I use Claude Code in a terminal pane inside VSCode, with the extension. So Claude does open a file tab with proposed changes
> Personally, I also like that usually it just presents to me only one change/file at a time, so it's easier for me to review
This is interesting. I haven't used Cursor, but one of my frustrations with Claude Code is that some of the individual changes it asks me to approve are too small for me to make a decision. There are cases where I almost denied a change initially, then realized Claude's approach made sense once I saw the full change set. Conversely, there are cases where I definitely should have stopped Claude earlier.
It doesn't help that Claude usually describes its changes after it has made the full series, instead of before.
...really, what I'd like is an easy way to go back in time, wherein going back to an earlier point in the conversation also reverted the state of the code. I can and do simulate this with git to some extent, but I'd prefer it as a layer on top of git. I want to use git to track other things.
I rarely had Cursor do unwanted changes for me. Maybe this is about prompting? I am very particular with what I want and I try to be as verbose as I can and explain the context as well plus hint which files I believe it should put attention to.
How can you prove you’re not a bot?
I get the feeling I’ve seen a comment like this somewhere before.
Tell us what you do—how, under what conditions, and in which programming languages. What exactly makes it better? Does it just search for files? Well, that’s hardly objective.
So far the impression is… well, you say it only seems better. But you won’t get far with that kind of reasoning.
Objectively, it now seems to me that Claude the cat is better, because everyone around says it’s better. Yet no one has actually explained why. So the hype is inflated out of thin air, and there are no objective reasons for it.
From what I see, you have to get your claude.md instructions right, and most of it is using planning mode. The CLI is exactly how you interact with it. It's less vibe code and what I'd call supervisory code.
It's less about writing code, more about building an engine that codes. It's hands off but unlike Cursor, it's not as eyes-off. You do observe and interrupt it. It is great for full on TDF - it figures out the feature, writes the test for the feature, fails the test, rewrites the code to pass. But at some point, you realize you got the instructions wrong and because you're outside the loop, you have to interrupt it.
I think it's a natural progression, but it's not for everyone. The people who hated not being able to write functions will hate claude code even more. But some people love writing their engines.
I'm just full of joy building again. It's hard being a manager, kids, jaded with the front end framework dance. Now I can just build build build and get my ideas out to users faster than they can decide.
What people haven't realised yet is that Cursor isn't a product, it's a collection of features that every product is feverishly working to add.
The key take away here is that save for the deep integration, there is a strategy for working with a best in class agent solution agnostic of tooling.
These learnings will eventually coalesce into "best practices" that people will apply using the editor or IDE of their choice and all these vscode forks will have died off.
Arguably this is why I'm still long on GitHub Copilot. Love them or hate them Microsoft/GitHub are proven winners in feature parity work and have such a big moat today. Why use a VS Code fork when you can "use the real thing"?
Microsoft/GitHub has even signaled confidence that they can compete feature by feature with the forks by even open sourcing much of the Copilot integration in VS Code.
Aesthetically, I like VS Code Copilot/Copilot Chat UIs/UX for the most part, certainly better than I like Claude Code and more than I like Cursor, too.
I used it for 2 weeks with the cheap $17/mo sub. It is equal parts amazing, and frustrating.
I ended up with 8k lines of rust and 12k lines of markdown. I think those markdown designs and explicit tasks were required the same way unit tests with a test harness are required to make the human-tool interaction work.
However, I’m not sure if the ‘magic’ is VC-subsidy or something else.
It did make rust (a language i do not know) feel like a scripting language. … the github repo is ‘knowseams’.
Expecting everyone to change their editor/ide is a big hurdle, and cursor doesn't support everything well like iOS development. A tool that works independently from your editor of choice is much easier to adopt. It's also much easier to script and automate.
Each use case, which for many is a project-by-project thing, likely determines the right tool for the job.
For new projects, I find Claude Code extremely helpful, as I start out with a business document, a top-level requirements document, and go from there. In the end (and with not a lot of work or time spent) I have a README, implementation plan, high-level architecture, milestones, and oftentimes a swagger spec, pipeline setup and a test harness.
IMHO pointing CC at a folder of a big typescript project is going to waste a ton of compute and tokens, for minimal value. That is not a good use of this tool. I also have a pretty strong opinion that a large, complex typescript codebase is a bad idea for humans too.
Point CC at a python or go repo and it is a whole 'nother experience. Also, starting out is where CC really shines as stated above.
For a big complex typescript repo I would want very specific, targeted help as opposed to agentic big-picture stuff. But that also minimizes the very reason I'd be reaching for help in the first place.
I’m very effective with JetBrains IDEs, VSCode is not in the same league. I’m very effective with a terminal. Claude Code is just enough of a bridge between models and my IDE to enhance my workflow without ruining my IDE. That’s it. I don’t pay $200.
Some of it is taste. Personally, I dislike VSCode and its descendants; it feels bloated and like I’m always being advertised to inside the product. I want my editor to disappear from thought, and Sublime does this for me.
A lot of people don't realize that you can completely change the vscode UI. All the side bars in particular - just get rid of them. You're left with a blank screen on which syntax-highlighted code appears with LSP and either the command palette or if you want to be more vim/emacs-y then basically every operation is key-bindable.
The key to productivity with these tools (as with most things) is a tight feedback loop.
Cursor has an amazing tab completion model. It uses a bunch of heuristics to try to understand what you're doing and accelerate it. It's a bit like a very advanced macro engine, except I don't have to twist my brain into a pretzel trying to program my editor - it just works, and when it doesn't I press Esc, which takes about half a second. Or I reach for the agentic mode, where the iteration cycle is more like 30 seconds to a minute.
With the fully agentic editors, it takes more like 15 to 30 minutes, and now it's a full on interruption in my flow. Reviewing the agent's output is a chore. It takes so much more mental bandwidth than the quick accept/reject cycle in the editor. And I have to choose between giving it network access (huge security hazard) or keeping it offline (crippling it in most codebases).
I find that for throwaway codebases where I don't care about maintenance/security/reliability, I can put up with this. It's also incredibly useful when working with a language or framework that I don't fully understand (but the model understands better). But for most of my work it produces poor results and ends up being a net negative for productivity - for now.
I'm sure this will improve, but for now I consistently get better results in Cursor.
And so you don’t think I just dropped in to try it out: no, I’ve been using Cursor every day for many months. I set up the rules very precisely, make maps, write instructions and constraints so the LLM understands how to work with the current codebase—where to find things, what to do, what not to do, what things should look like. I try to write as concisely as possible so everything fits in the context window.
I have a monorepo, so different instructions and rules live in different corners of it, which I manually add as needed. Doing all this with Claude is hard: it kind of works, but it’s a kludge. It’s much easier to manage through the UI. As the saying goes, it’s better to see something once than to remember it ten times, type a command, and configure it.
I can say the same about Vim and Emacs users. No one has yet proven to me they can code and navigate faster than an ordinary programmer using a trackpad or a mouse and keyboard. It’s purely a matter of taste. I’ve noticed that people who love those tools are just bored at work and want to entertain their brains. That’s neither good nor bad, but it doesn’t give a real boost.
By the way, there’s a study (a bit old, admittedly) showing that working with an LLM still doesn’t provide a massive speed-up in programming. Yes, it spits out code quickly, but assembling a finished result takes much longer: you have to review, polish, start over, throw things out, start again. It’s not that simple.
Speaking of Claude, he’s a real master at shitting in the code. At the speed of sound he generates a ton of unnecessary code even when you ask him not to. You ask for something minimalist, nothing extra—he still slaps on a pile of code with useless tests that outsmart themselves and don’t work.
That’s the downside. Overall, it’s easier to program when you just say what to do instead of sitting there straining your own brain. But even then it’s not simple. If you yourself haven’t figured out very carefully what you’re doing, you’ll end up with crap. I almost always throw away what I wrote with an LLM when I was tired. I don’t think there’s ever been an exception.
The only way to write something decent is to dig in thoroughly: draw diagrams, write everything out, and only then tell the LLM exactly what to do. Then double-check, make sure it didn’t write anything extra, delete the excess. And only like that, in small chunks. The “make me a feature, I pressed a button and walked away” mode doesn’t work if the task is even slightly complex.
Yeah, I got carried away—had to let it out. I have a lot to say about LLMs and programming with them, and not just about Cursor and Claude. The tools completely upended the way we program...
I remember a few projects before all the AI where I would setup templates, little code generators, patterns to follow. Just make it really easy to do the right things. Was so easy to get things done. Was a small team, like minded, easy to row in the same direction. Your post reminded me of that.
I too notice this about Claude, I've written commands, massaged Claude.md, even hooks. Given it very precise feature guides. I see the same issues you do. Feels like Claude has a lazy lever built in to it.
I play GPT O3 off it constantly, it takes the spec, a repomix slice of the Claude work and gives a new gap.md for Claude to pursue. Rinse and repeat. It works but your cursor flow seems better.
My highest velocity was about 1.6 fib complexity points a day over thirty years, now it's 4.3 with Claude the last three weeks which is nuts. I'm a total hack, I think I could get it up to nine if I was a bit more organized. Probably won't have to, just wait for the next iteration of the Claude models.
My biggest piece of starting advice would be use it for exploration not generation. It can be great for understanding code bases and looking at git history.
Context is key, so it is also really helpful having a CLAUDE.md file; the /init command can create one for you.
If you are going to use it for generation (writing code); plan mode is a must. Hit shift-tab twice.
Finally; I'm mostly using the claude 4 sonnet model, but make sure to tell it to "ultrathink" (use those words); this means it can use more thinking tokens.
I think you need to be a bit more explicit in your usage. I use Claude Code as the plugin in Cursor, to me the marriage of all the great, tastes great, less filling. You see all the changes as you normally would in VSCode / Cursor, but the Claude Code command line UI is absolutely bonkers better than the Cursor native one. They really have it dialed in beautifully in my opinion.
I used Cursor daily for about six months before switching to CC and it took awhile. TUI is not my first choice. But their tools and prompts make it work fare more coherently, and I've had far fewer train wrecks in my code since fully switching a few weeks ago. The IDE extension helps.
Cursor and code completion is such a time saver for me. Having the next few lines guessed feels magic.
Having an agent completely design/write a feature still feels weird. I like everything being hand written, even if I actually just tab completed and edited it slightly
So far my feeling is that cursor is a bit better for working on existing large codebases, whereas claude does a good job planning and building greenfield projects that require a lot of code.
That does net out to meaning that Cursor gets used way more often, atm.
I am a software developer with over 25 years of professional experience and have been working with coding agents for quite some time starting with AutoGPT and now using Claude Code almost 24/7 orchestrated via Task Master to automatically spin up new instances working on a multi layer project.
You are absolutely right. A large portion are influencers (I would estimate around 95% of those you see on YouTube and forums) that are full of hype. I think most are not affiliated with Anthropic or any vendor, they are just trying to sell a course, ebook or some "get rich with AI" scheme.
What I appreciate about Claude Code:
- Since it is a terminal/CLI tool it can be run headlessly from cron jobs or scripts. This makes it easy to automate.
- I appreciate the predictable pricing model. A flat monthly fee gives me access to Claude Sonnet and Opus 4 in five-hour sessions each with its own usage limit that resets at the start of a new session. There is a fair use policy of around 50 sessions per month, but I haven’t hit that yet. I deliberately run only one instance at a time as I prefer to use it responsibly unlike some of the "vibe" influencers who seem to push it to the limit.
That's it. Despite being a CLI based tool, Claude Code is remarkably out of the box for what it offers.
That said, no coding agent I have encountered can fully ingest a large inconsistent legacy codebase especially one with mixed architectures that accumulated over years. This limitation is mainly due to context size constraints, but I expect this to improve as context windows grow.
i hate terminal stuff and refuse to write code in terminals, and i still think claude code has better results than cursor IDE with sonnet 4. it might be a mixture of it mixing in opus (which i never really used with cursor) or it might be that there's a bigger context window or its agentic process is somewhat different. im not entirely sure. but i feel like it gets things right more consistently and introduces fewer issues. it might also be the use of CLAUDE.md which i think has helped a ton in consistently making sure its following best practices for my project
Claude Code + Cursor is my setup. Claude Code is my workhorse that I use for most tasks.
For small tiny quick changes, I use Cursor in auto.
For architecture consulting I use Cursor chat with Grok 4.
Claude Code is much better at banging out features than Cursor’s Claude. And Claude itself is better than other models as a coding workhorse.
All that said: while we may all code, we are building wildly different things that have much different specific problems to solve so it doesn’t surprise me that there isn’t a universal setup that works best for everybody.
Die hard fans. I tried so many Claude models. Some are ok. Really. Surprisingly some versions of Sonnet are better than Opus. So the latest isn't always the greatest. Models are specialized sometimes (intentionally designed that way or not).
I think people just need to try a bunch to be honest. I think that we will get to a point (or are already there) where some models just resonate better with you and your communication (prompt) style.
But after using a bunch...I have to say that Gemini 2.5 Pro is consistently the best one I've used yet. It's pricey, but it just works.
I'm still looking for a good local model, but it's just going to be a while until anything local can match Gemini. It will eventually I think, but it'll take some time.
I probably won't be using Claude Code, but I'm glad it works for some folks.
IMO: The people who are obsessed with Claude Code are the people who weren't really engineers to begin with. For them, any level of productivity is "extremely impressive" and "going to kill engineering jobs" because they never really understood what software engineers do, and had no sense of what the demarcations on the scale of productivity even should be.
The reason why they like Claude Code specifically over Cursor isn't because they were fans of terminal windows; on the contrary, its because CC is simpler. Cursor is complicated, and its interface communicates to the user that eventually you might be grabbing the wheel. Of course, experienced engineers want to grab the wheel; working together with the AI toward some goal. But these CC-stans don't. All that extra stuff in the UI scares them, because they wouldn't know what to do with it if they had to do something with it.
Its this particular kind of person that's also all over /r/ClaudeAI or /r/Cursor complaining about rate limits. If you've ever used these products, you'd realize very quickly: The only way you're hitting rate limits so quickly on the paid plans is if the only code that's being outputted is from the AI, nonstop, for eight hours a day, using only the most expensive and intelligent models. The only people who do this are the people who have no brain of their own to contribute to the process. Most CC/Cursor users don't hit rate limits, because they're working with the AI, like a tool, not managing it like a direct report.
For me the best part about AI is that when I'm feeling lazy, I can tell the AI to do it. Whether it gives me gold or gives me shit, it doesn't matter, because I have now started my work.
It's the white page problem, that LLMs solve handily. Instead of facing the daunting task of building back up a complex mental model, I can ask the machine "yo, what were we doing? what's this thing? ok, how about you give it a spin and show me" and all of the sudden I'm back in it and can get cracking. That, and rubber ducking, and speeding up yak shaving to the nth degree really make this thing very useful to me. I also have various data sources hooked up (slack, notion, linear) so it's also a task management and project management tool for me.
Re: the "white page problem", that is just known as motivation inertia. You can overcome it by training yourself to agree with yourself to "just do it" for 5 minutes, even if you really, really don't want to. If you're still demotivated after that, fine. But 9 out of 10 times, once you've started, it's surprisingly easy to keep the momentum up. This is also great for going to the gym or cleaning up your home, where an LLM can't come to the rescue :)
Re: usage of LLMs, that is honestly the way I like to use LLMs. That and auto-complete.
It's great for creating a bird's-eye view of a project because that is very fuzzy and no granular details are needed yet. And it's great at being fancy autocomplete, with its stochastic bones. But the middle part where all the complexity and edge cases are is where LLMs still fail a lot. I shudder for the teams that have to PR review devs that jubilantly declare they have "5x'ed" their output with LLMs, senior or not.
What is even more worrisome is that the brain is a muscle. We have to exercise it with thinking, hence why puzzlers stay sharp at old age. The more you outsource your code (or creative writing) thinking, the worse you get at it, and the more your brain atrophies. You're already seeing it with Claude Code, where devs panic when they hit the limit because they just might have to code unassisted.
Maybe there is a reason why is your brain hesitating (e.g. low energy) and pushing it with LLMs would blow it up at some point in the future if the cause was not fixed in the meantime? Covid showed me (in a very accentuated way) that many of the times I was procrastinating was instead brain throttling due to low energy, protecting itself.
I thought this as well, but I just got burned in a way that caused me to lose so much time: I was feeling lazy and allowed AI to write some code for me. It looked good and compiled so I committed and pushed it. Weeks later I experienced a crash that I couldn't pinpoint. After hours of debugging, I eventually realized the culprit was that bit of code created by AI from weeks ago; it used a function that was defined in my code in a way that wasn't intended, causing a panic sometimes and weird off-by-one errors other times. The offending function was only a few lines of code. Had I not been lazy and just took 10 minutes to write it, I would have saved myself a whole afternoon of frustrating debugging.
Lesson learned: being lazy with AI has a hidden cost.
At the end of the day when I'd be thrashing or reverting as much as I write, I can let Jesus take the wheel for a bit to refresh.
On small issues it's usually just a glance over the diff, on harder issues it's not challenging to scold it into a good path once something starts coming together, as long as it's a localized edit with a problem I understand. I'll often take over when it's 40-60% there, which is only possible b/c it does a good job of following todo lists.
I've moved into a good daily workflow that emphasizes my own crafting during the times I'm sharp like mornings, and lets AI do the overtime and grunt work while I prepare for tomorrow or do more thoughtful writing and design.
So glad I've found someone else who has this workflow.
I spend probably 70% of my active coding time coding. The rest is using LLMs to keep making progress but give my brain a bit of a break while I recharge, being more supervisory with what's happening, and then taking over if necessary or after the 10-15 minutes it takes for me to start caring again.
Even if I want to do it myself, I'll ask it to write it a plan and toss it in a markdown file.
It gave me a shit plan today. Basically I asked it to refactor a block of prototype code that consisted of 40 files or so. It went the wrong way and tried to demolish it from the bottom up instead of making it 100% backwards compatible. If it made a mistake we would have taken forever to debug it.
But yeah, it gave me something to attack. And the plan was fixed within an hour. If I tried to make one myself, I would have frozen from the complexity or gone in circles documenting it.
I've had great success using AI to translate my thoughts into actual words on a page (not just for software development, but also amateur writing). Bridging the vocabulary gap.
Yes, it helps a lot overcome that initial momentum. I also find it helps at the end of the day when I’m tired. I can just tell it to do the work a little bit at a time and review/fix the output. Takes less out of me.
Claude Code is hard to describe. It’s almost like I changed jobs when I started using it. I’ve been all-in with Claude as a workflow tool, but this is literally steroids.
If you haven’t tried it, I can’t recommend it enough. It’s the first time it really does feel like working with a junior engineer to me.
Weirdly enough I have the opposite experience where it will take several minutes to do something, then I go in and debug for a while because the app has become fubar, then finally realize it did the whole thing incorrectly and throw it all away.
And I reach for Claude quite a bit because if it worked as well for me like everyone here says, that would be amazing.
But at best it’ll get a bunch of boilerplate done after some manual debugging, at worst I spend an hour and some amount of tokens on a total dead end
Some great advice I've found that seems to work very well: ask it to keep a succinct journal of all the issues and roadblocks found during the project development, and what was done to resolve or circumvent them. As for avoiding bloating the code base with scatterbrained changes, having a tidy architecture with good separation of concerns helps leading it into working solutions, but you need to actively guide it. For someone that enjoys problem-solving more than actually implementing them, it's very fun.
Sigh. As others have commented, over and over again in the last 6 months we've seen discussions on HN with the same basic variation of "Claude Code [or whatever] is amazing" with a reply along the lines of "It doesn't work for me, it just creates a bunch of slop in my codebase."
I sympathize with both experiences and have had both. But I think we've reached the point where such posts (both positive and negative) are _completely useless_, unless they're accompanied with a careful summary of at least:
* what kind of codebase you were working on (language, tech stack, business domain, size, age, level of cleanliness,
number of contributors)
* what exactly you were trying to do
* how much experience you have with the AI tool
* is your tool set up so it can get a feedback loop from changes, e.g. by running tests
* how much prompting did you give it; do you have CLAUDE.me files in your codebase
and so on.
As others pointed out, TFA also has the problem of not being specific about most of this.
We are still learning as an industry how to use these tools best. Yes, we know they work really well for some people and others have bad experiences. Let's try and move the discussion beyond that!
do you create the claude.md files at several levels of your folder structure, so you can teach it how to do different things? Configuring these default system prompts is required to get it to work well.
I'd definitely watch Boris's intro video below [1]
You can tell Claude to verify its work. I’m using it for data analysis tasks and I always have it check the raw data for accuracy. It was a whole different ballgame when I started doing that.
Clear instructions go a long way, asking it to review work, asking it to debug problems, etc. definitely helps.
This has a lot to do with how you structure your codebase; if you have repeatable patterns that make conventions obvious, it will follow them for the most part.
When it drops in something hacky, I use that to verify the functionality is correct and then prompt a refactor to make it follow better conventions.
The quality of the generated code is inversely proportional to the time it take to generate it. If you let Claude Code work alone for more than 300 seconds you will receive garbage code. Take that as a hint, if it can't finish the task in this time it means you are asking too much. Break up your feature and try with a smaller feature.
Yeah that is kind of my experience as well. And - according to the friend who highly recommended it - I gave it a task that is "easily within its capabilities". Since I don't think I'm being gaslighted, I suspect it's me using it wrong. But I really can't figure out why. And I'm on my third attempt now..
Just got it at work today and it’s a dramatic step change beyond Cursor despite using the same foundation models. Very surprising! There was a task a month ago where AI assistance was a big net negative. Did the same thing today w/ Claude Code in 20ish minutes. And for <$10 in API usage!
Much less context babysitting too. Claude code is really good at finding the things it needs and adding them to its context. I find Cursor’s agent mode ceases to be useful at a task time horizon of 3-5 minutes but Claude Code can chug away for 10+ minutes and make meaningful progress without getting stuck in loops.
Again, all very surprising given that I use sonnet 4 w/ cursor + sometimes Gemini 2.5 pro. Claude Code is just so good with tools and not getting stuck.
Even though it’s the same model cursor adds a massive system prompt to every request. And it’s shit and lobotomises the models. After the rug pull I’m exclusive Claude code at the end of my billing period or when cursor cut me off the $60 a month plan—-which will probably come first—-a bit over halfway into my month.
> It’s the first time it really does feel like working with a junior engineer to me.
I have mixed feelings; because this means there’s really no business reason to ever hire a junior; but it also (I think) threatens the stability of senior level jobs long term, especially as seniors slowly lose their knowledge and let Claude take care of things. The result is basically: When did you get into this field, by year?
I’m actually almost afraid I need to start crunching Leetcode, learning other languages, and then apply to DoD-like jobs where Claude Code (or other code security concerns) mean they need actual honest programmers without assistance.
However, the future is never certain, and nothing is ever inevitable.
It's a junior engineer that doesn't learn - they make the same mistakes even after being corrected the second that falls out their context window (even often with "corrections" still there...), they struggle to abstract those categories of mistakes to avoid making similar ones in the future, and (by the looks of it) will never be "the senior". "Hiring a Junior" should really be seen as an investment more than immediate output.
I keep being told that $(WHATEVER MODEL) is the greatest thing ever, but every time I actually try to use them they're of limited (but admittedly non-zero) usefulness. There's only so many breathless blogs or comments I can read that just don't mesh with the reality I personally see.
Maybe it's sector? I generally work on Systems/OS/Drivers, large code bases in languages like C, C++ and Rust. Most larger than context windows even before you look at things like API documentation. Even as a "search and summarizer" tool I've found it completely wrong in enough cases to be functionally worthless as the time required to correct and check the output isn't a saving. But they can be handy for "autocompletion+" - like "here's a similar existing block of code, now do the same but with (changes)".
They generally seem pretty good at being like a template engine on non-templated code, so thing like renaming/refactoring or similar structure recognition can be handy. Which I suspect might also explain some of those breathless blog posts - I've seen loads which say "Any non-coder can make a simple app in seconds!" - but you could already do that, there's a million "Simple App Tutorial" codebases that would match whatever license you want, copy one, change the name at the top and you're 99% of the way to the "Wow Magic End Result!" often described.
I find it pretty interesting that it's a roughly 2,500 word article on "using Claude Code" and they never once actually explain what they're using it for, what type of project they're coding. It's all just so generic. I read some of it then realize that there was absolutely no substance in what I just read.
It's also another in my growing list of data points towards my opinion that if an author posts meme pictures in their article, it's probably not an article I'm interested in reading.
It's always POC apps in js or python, or very small libraries in other popular languages with good structure from the start. There are ways to make them somewhat better in other cases (automated testing/validation/linting being a big one), but for the type of thing that 95% of developers are doing day to day (working on a big, sprawling code base where none of those attributes apply), it's not close to being there.
The tools really do shine where they're good though. They're amazing. But the moment you try to do the more "serious" work with them, it falls apart rapidly.
I say this as someone that uses the tools every day. The only explanation that makes sense to me is that the "you don't get it, they're amazing at everything" people just aren't working on anything even remotely complicated. Or it's confirmation bias that they're only remembering the good results - as we saw with last week's study on the impact of these tools on open source development (perceived productivity was up, real productivity was down). Until we start seeing examples to the contrary, IMO it's not worth thinking that much about. Use them at what they're good at, don't use them for other tasks.
LLMs don't have to be "all or nothing". They absolutely are not good at everything, but that doesn't mean they aren't good at anything.
When I read these LLM in coding discussions, I'm reminded a lot of online dating discussions. Someone will post "I'm really having a tough time dating. I tried X (e.g. a dating app) but I had a tough experience." Someone will respond "I tried X and had great success. Highly recommended." Seems confounding, but when you click into their profiles to see pictures of each person, it becomes abundantly clear why these people report different experiences.
Not to dog the author too hard, but a look at their Github profile says a lot about the projects they've worked on and what kind of dev they are. Not much there in terms of projects or code output, but they do have 15k followers on Twitter, where they post frequently about LLMs to their audience.
They aren't talking about the tasks and the domains they're using because that's incidental; what they really want to do is just talk about LLMs to their online audience, not ship code.
I’m a TALL developer, so Laravel, Livewire, Tailwind, Alpine.
It’s nice because 3/4 of those are well-known but not “default” industry choices and it still handles them very well.
So there’s a Laravel CRM builder called Filament which is really fun to work in. Claude does a great job with that. It’s a tremendous amount of boilerplate with clear documentation, so it makes sense that Claude would do well.
The thing I appreciate though is that CC as an agent is able to do a lot in one go.
I’ve also hooked CC up to a read-only API for a client, and I need to consume all of the data on that API for the transition to a Filament app. Claude is currently determining the schema, replicating it in Laravel, and doing a full pull of API records into Laravel models, all on its own. It’s been running for 10 minutes with no interruption and I expect will perform flawlessly at that.
I invest a lot of energy in prompt preparation. My prompts are usually about 200 words for a feature, and I’ll go back and forth with an LLM to make sure it thinks it’s clear enough.
I haven't had great luck with Claude writing Windows Win32 (using MFC) in C++. It invents messages and APIs all the time that read like exactly what I want it to do.
I'd think Win32 development would be something AIs are very strong at because it's so old, so well documented, and there's a ton of code out there for it to read. Yet it still struggles with the differences between Windows messages, control notification messages, and command messages.
I opinion is that the AI is the distilled average of all the code it can scrape. For the stuff I'm good at and work on every day it doesn't help much beyond some handy code completions. For stuff I'm below average at like bash commands and JS it helps me get up to average. The most valuable to me is if I can use it to learn something - it gives some good alternatives and ideas if you have something mainstream.
The reason is probably complexity and the task at hand.
In my experience, LLMs are great at small tasks (bash or python scripts); good at simple CRUD stuff (js, ts, html, css, python); good at prototyping; good at documentation; okay at writing unit tests; okay at adding simple features in more complex databases;
Anything more complex and I find it pretty much unusable, even with Claude 4. More complex C++ codebases; more niche libraries; ML, CV, more mathsy domains that require reasoning.
I've had the same experience, although I feel like Claude is far more than a junior to me. It's ability to propose options, make recommendations, and illustrate trade-offs is just unreal.
Does anyone have any usage guides they can recommend to feel this way about using Claude code, other than the OP article? I fired it up yesterday for about an hour and tried it on a couple tickets and it felt like a total waste of time. The answers it gave were absurdly incorrect - I was being quite specific in my prompting and it seemed to be acquiring the proper context, but just doing nothing like what I was asking.
E.g. I asked it to swap all on change handlers in a component to modify a use State rather than directly fire a network request, and then add on blurs for the actual network request. It didn't add use states and just added on blurs that sent network requests to the wrong endpoint. Bizarre.
I liked Claude Code when I used it initially to document a legacy codebase. The developer who maintains the system reviewed the documentation, and said it was spot-on.
But the other day I asked it to help add boundary logging to another legacy codebase and it produced some horrible, duplicated and redundant code. I see these huge Claude instruction files people share on social media, and I have to wonder...
Not sure if they're rationing "the smarts" or performance is highly variable.
There are some things in there that really take this from an average tool to something great. For example, a lot of people have no idea that it recognizes different levels of reasoning and allocates a bigger number of “thinking tokens” depending on what you ask (including using “ultrathink” to max out the thinking budget).
I honestly think that people who STILL get mostly garbage outputs just aren’t using it correctly.
Not to mention the fact that people often don't use Opus 4 and stay with Sonnet to save money.
> it really does feel like working with a junior engineer to me.
I agree. It reminds me of this one junior engineer I worked with who produced awful code, and it would take longer to explain stuff to him than to just do it myself, let alone all the extra time I had to spend reviewing his awful PRs. I had hoped he would improve over time, but he took my PR comments personally and refused to keep working with me. At least Claude doesn't have an attitude.
I found cursor much better than Claude Code. Running Claude code it did so many commands and internal prompting to get a small thing done and ate up tonnes of my quota. Cursor on the other hand did it super quick and straight to the point. Claude code just got stuck in grep hell
I agree with the comparison to steroids, but then I've seen people go through the health issues caused by steroids so we might mean different things by that comparison.
in what sense, instead of doing your job which I assume you've been doing successfully for many years you now ask Claude to do it for you and then have to review it?
There must at this point be lots and lots of actual walkthroughs of people coding using Claude Code, or whatever, and producing real world apps or libraries with them right? Would be neat to have a list because this is what I want to read (or watch), rather than people just continuously telling me all this is amazing but not showing me it’s amazing.
Something really feels off about the whole thing. I use Claude code. I like it, it definitely saves me time reading docs or looking on stack overflow. It’s a phenomenal tool.
If we are to believe the hype though, shouldn’t these tools be launching software into the stratosphere? Like the CEO of stripe said AI tools provide a x100 increase in productivity. That was 3-4months ago. Shouldn’t stripe be launching rockets in to space now since that’s technically 400months of dev time? Microsoft is reportedly all in on AI coding. Shouldn’t Teams be the best, most rock solid software in existence now? There is so much hype around these tools being a super charger for more than a year, but the actual software landscape looks kind of the same to me as it did 3-4 years ago.
Whatever it produces still needs to be carefully reviewed and guided. Context switching as a human programmer is very hard so you need to focus on the same specific task, which is harder to not switch to social media or IRL while waiting for it. And you're going to be on the same branch for the same ticket, git doesn't let you do multiple at once (at least I'm not set up to). Not sure where the productivity scaling would come from outside of rapid experimentation on bad ideas until you find the right one, and of course rapid autocomplete, faster debugging, much fancy global find/replace type stuff.
I use it quite aggressively and I'd probably only estimate 1.5x on average.
Not world changing because we all mostly work on boring stuff and have endless backlogs.
Despite living in an age of supposedly transformative brainstorming and creative technologies, we’re also paradoxically inhabiting a time with less creativity and vision than ever. :)
Maybe this discrepancy is down to something like Claude code reducing the amount of brain power exhorted. If you have to do 80% less thinking to accomplish a task but the task takes just as long, you may (even rightfully) feel five times more productive even though output didn't change.
And is this a good thing since you can (in theory) multitask and work longer hours, or bad because you're acquiring cognitive debt (see "Your Brain on ChatGPT")?
I think it will. The Claude subscription only launched in May. A software company with a large code base, legacy code, paying customers,SOC, GDPR etc is a large boat to turn. I still think we are only months away from realizing the pace you describe
I see two trends recently:
1. low skill people using it for trivial projects.
2. devs writing out the whole app into memory/context down to the names of the files, interfaces, technologies, preparing the testing, compilation framework and then hand-holding the llm to arrive (eventually) at an acceptable solution. Example: https://www.youtube.com/watch?v=Y4_YYrIKLac
80% (99%?) of what you hear about llms are from the first group, amplified by influencers.
I'm guessing people feel the productivity boost because documenting/talking to/guiding/prompting/correcting an LLM is less mentally taxing than actually doing the work yourself even though time taken or overall effort is the same. They underestimate the amount of work they've had to put in to get something acceptable out of it.
This is my take: I’ve been professionally developing software for 25-years. I use Claude Code daily and find it really useful. It does take a lot of effort— particularly in code review, which is my least favorite part of the job— in order to get useful, high quality results. For small, focused or boilerplate-heavy stuff, it is excellent, though. Also, the most fun part of programming (to me) is solving the problem; not so much actual implementation, so agents haven’t removed the fun yet.
> 2. devs writing out the whole app into memory/context down to the names of the files, interfaces, technologies, preparing the testing, compilation framework and then hand-holding the llm to arrive (eventually) at an acceptable solution
I've just built a mobile app that does have a few sophisticated features. About 120 hours into it. (GPS, video manipulation, memory concerns) Never built on mobile before, I don't think I have the technical chops to do these hard parts on my own given the time it would have taken and the lack of focused blocks of time in my current life. It would take me a thousand hours without the Claude.
100% agree, I have been looking for a YouTube video or stream of someone leveraging AI to get their productivity boost, but I haven't found anything that made me think "okay, that really speeds up things"
It was extremely telling to me that the Zed editor team put out a video about using their AI interface and I don't remember what model they used but they asked it to add a new toggle for a feature and then spent half they video demonstrating their admittedly excellent review workflow to accept or reject the AI generated code and you could directly see how useless it was down to adding completely superfluous new lines randomly and the explanation was "it just does that sometimes"
I'm really not seeing these massive gains in my workflow either and maybe it's the nature of my general work but it's baffling how every use case for programming I'm seeing on YouTube is so surface level. At this point I've given up and don't use it at all
this sounds like a cop out, but honestly you will probably see the most vocal on both sides of this here while vast majority are just quietly doing working and doing their stuff (ironic i'm writing this).
i feel like some kind of shill, but honestly i'm anywhere from 1.5x to 10x on certain tasks. the main benefit is that i can reduce a lot of cognitive load on tasks where they are either 1) exploratory 2) throwaway 3) boilerplate-ish/refactor type stuff. because of that i have a more consistent baseline.
i still code "by hand". i still have to babysit and review almost all the lines, i don't just let it run for hours and try to review it at the end (nightmare). production app that's been running for years. i don't post youtube videos bc i don't have the time to set it up and try to disprove the "naysayers" (nor does that even matter) and its code i can't share.
the caveat here is we are a super lean team so probably i have more context into the entire system and can identify problems early on and head them off. also i have a vested interest in increasing efficiency for myself wheras if you're part of a corpo ur probably doing more work for the same comp.
By your own reckoning. There was that recent study showing how senior devs using AI thought they were 20% faster, when they were objectively 20% slower.
I started using Claude code (CC) a couple weeks back and have some very positive outcomes. For clarity, I have been in the IT field since 1990, and my background is mainly infrastructure engineering (now DevOps). I don't write code professionally; I write tools as needed to accomplish tasks. That said, I understand end-to-end systems and the parts in the middle pretty well.
Here are some projects Claude has helped create:
1. Apache Airflow "DAG" (cron jobs) to automate dumping data from an on-prem PGSQL server to a cloud bucket. I have limited Python skills, but CC helped me focus on what I wanted to get done instead of worrying about code. It was an iterative process over a couple of days, but the net result is we now have a working model to easily perform on-prem to cloud data migrations. The Python code is complex with lots of edge conditions, but it is very readable and makes perfect sense.
2. Custom dashboard to correlate HAProxy server stats with run-time container (LXC) hooks. In this case, we needed to make sure some system services were running properly even if HAProxy said the container was running. To my surprise, CC immediately knew how to parse the HAProxy status output and match that with internal container processes. The net for this project is a very nice dashboard that tells us exactly if the container is up/down or some services inside the container are up/down. And, it even gives us detailed metrics to tell us if PGSQL replication is lagging too far behind the production server.
3. Billing summary for cloud provider. For this use case, we wanted to get a complete billing summary from our cloud provider - each VM, storage bucket, network connection, etc. And, for each object, we needed a full breakdown (VM with storage, network, compute pricing). It took a few days to get it done, but the result is a very, very nice tool that gives us a complete breakdown of what each resource costs. The first time I got it working 100%, we were able to easily save a few thousand $$ from our bill due to unused resources allocated long ago. And, to be clear, I knew nothing about API calls to the cloud provider to get this data much less the complexities of creating a web page to display the data.
4. Custom "DB Rebuild" web app. We run a number of DBs in in our dev/test network that need to get refreshed for testing. The DB guys don't know much about servers, containers, or specific commands to rebuild the DBs, so this tool is perfect. It provides a simple "rebuild db" button with status messages, etc. I wrote this with CC in a day or so, and the DB guys really like the workflow (easy for them). No need to Github tickets to do DB rebuilds; they can easily do it themselves.
Again, the key is focusing my energy on solving problems, not becoming a python/go/javascript expert. And, CC really helps me here. The productivity our team has achieved over the past few weeks is nothing short of amazing. We are creating tools that would require hiring expert coders to write, and giving us the ability to quickly iterate on new business ideas.
Sometimes, you'll just have a really productive session with Claude Code doing a specific thing that maybe you need to do a lot of.
One trick I have gotten some milage out of was this: have Claude Code research Slash commands, then make a slash command to turn the previous conversation into a slash command.
That was cool and great! But then, of course you inevitably will interrupt it and need to do stuff to correct it, or to make a change or "not like that!" or "use this tool" or "think harder before you try that" or "think about the big picture"
... So you do that. And then you ask it to make a command and it figures out you want a /improve-command command.
So now you have primitives to build on!
Here are my current iterations of these commands (not saying they are optimal!)
Oh do let me tell you how much effort I put into tending my non-deterministic garden or relationships or hell even the contractors I am using to renovate my house!
A few small markdown documents and putting in the time to understand something interesting hardly seems a steep price!
It's great for me. I have a claude.md at the root of every folder generally, outlined in piped text for minimal context addition about the rulesets for that folder, it always creates tests for what it's doing and is set to do so in a very specific folder in a very specific way otherwise it tries to create debug files instead. I also have set rules for re-use so that way it doesn't proliferate with "enhanced" class variants or structures and always tries to leverage what exists instead of bringing in new things unless absolutely necessary. The way I talk to it is very specific as well, I don't write huge prose, I don't set up huge PRDs and often I will only do planning if its something that I am myself unsure about. The only time I will do large text input is when I know that the LLM won't have context (it's newer than it's knowledge window).
I generally get great 1-shot (one input and the final output after all tasks are done) comments. I have moved past claude code though I am using the CLI itself with another model although I was using claude code and my reason for switching isn't that claude was a bad model it's just that it was expensive and I have access to larger models for cheaper. The CLI is the real power not the model itself per-se. Opus does perform a little better than others.
It's totally made it so I can do the code that I like to do while it works on other things during that time. I have about 60-70 different agent streams going at a time atm. Codebases sizes vary, the largest one right now is about 200m tokens (react, typescript, golang) in total and it does a good job. I've only had to tell it twice to do something differently.
I'm using fine-tuned models some with 600b+ parameters and some with 1t+ kimi base / deepseek base and others are general purpose that are from huggingface but I use those through mcp tools
What do you consider an “agent stream”? I can’t even imagine the cognitive overhead of managing 60-70 agents let alone the physical ability to churn through them as they complete their work and re-launch them.
My own experience is that it is below sonnet and opus 4.0 on capability - but better than gemini 2.5 pro on tool calling. It's really worth trying if you don't want to spend the $100 or $200 per month on Claude Max. I love how succinct the model is.
> you can use CC with any model via
Anthropic should just open source Claude Code - they're in a position to become the VS Code of cli coding agents.
I tried gemini2.5 and while it is certainly a very strong model you really notice that it was not trained to be 'agentic'/with strong initiative for tool calling. Oftentimes it would make a plan, I'd say 'go ahead' and it just replied something like 'I made a todo list we are ready to implement' or something similar lol. You really had to push it to action and the whole CC experience fell apart a bit.
Corollary if you're unfamiliar with how CC works (because you've never been able to consider it for its price, like me) – the CC client is freely available over 'npm'.
How are people using this without getting rate limited non stop? I pay for Claude Pro and I sometimes can’t go more than 5 prompts in an hour without it saying I need to wait 4 hours for a cooldown. I feel like I’m using it wrong or something, it’s such a frustrating experience. How do you give it any real code context without using all your tokens so quickly?
Try giving it a repomap, eg by including it in CLAUDE.md. It should pull in less files (context) that way. Exactly telling it which files you suspect need editing also helps. If you let it run scripts, make sure to tell it to grep out only the relevant output, or pipe to /dev/null.
I have the same issue and in recent days I seem to have gotten an extra helping of overload errors which hit extra hard when I realize how much this thing costs.
Edit: I see a sibling comment mention the Max plan. I wanna be clear that I am not talking about rate limits here but actual models being inaccessible - so not a rate limit issue. I hope Anthropic figures this out fast, because it is souring me on Claude Code a bit.
I haven't used Claude Code a lot, but I was using about $2-$5/hour, but it varied a lot. If I used it 6 hours/day and worked a normal 21 workday month (126 hours), then I would rack up $250-$630/month in API costs. I think I could be a more efficient with practice (maybe $1-$3/hour?). If you think you are seriously going to use it, then the $100/month or $200/month subscriptions could definitely be worth it as long as you aren't getting rate limited.
If you aren't sure whether to pull the trigger on a subscription, I would put $5-$10 into an API console account and use CC with an API key.
I wish there was a Max trial (while on Pro) to test if this was the case or not. Even if it was just a 24 hour trial. Max is an expensive trigger to pull, and hope it just solves this.
Readit News
Every time I read comments saying Claude Code is far better than Cursor, I fire it up, pay for a subscription, and run it on a large, complex TypeScript codebase. First, the whole process takes a hell of a lot of time. Second, the learning curve is steep: you have to work through the terminal and type commands.
And the outcome is exactly the same as with the Claude that’s built into Cursor—only slower, less clear, and the generated code is harder to review afterward. I don’t know… At this point my only impression is that all those influencers in the comments are either sponsored, or they’ve already shelled out their $200 and are now defending their choice. Or they simply haven’t used Cursor enough to figure out how to get the most out of it.
I still can’t see any real advantage to Claude Code, other than supposedly higher limits. I don’t get it. I’ve already paid for Claude Code, and I’m also paying for Cursor Pro, which is another $200, but I’m more productive with Cursor so far.
I’ve been programming for 18 years, write a ton of code every single day, and I can say Cursor gives me more. I switch between Gemini 2.5 Pro—when I need to handle tasks with a big, long context—and Claude 4.0 for routine stuff.
So no one has convinced me yet, and I haven’t seen any other benefit. Maybe later… I don’t know.
I think it can also be deceptive the same way it can be in basically any trade: it’s easy for the job to get “done” and work. It’s hard to do it properly in a way that it has a lasting durability. With A.I. we can spit out these programs that work and look done. And for prototypes or throwaways and such, that’s probably wonderful! But that’s not going to fly if you’re building a house to spec for people who are going to live in it for 30 years.
Let’s be honest, that’s what most companies pay good salaries for most software developers for.
When staring at a new job or project, do you more find yourself praising the architecture and quality? Or wondering how it got to this point?
I'm not sure why. However, Claude does seem to know better where things are and knows not to make unnecessary changes. I still need to guide it and tell it to do things differently some times, but it feels like it's a lot more effective
Personally, I also like that usually it just presents to me only one change/file at a time, so it's easier for me to review. Cursor might open several files at once, each with a tons of changes, which makes it a lot harder for me to understand quickly
Btw, I use Claude Code in a terminal pane inside VSCode, with the extension. So Claude does open a file tab with proposed changes
This is interesting. I haven't used Cursor, but one of my frustrations with Claude Code is that some of the individual changes it asks me to approve are too small for me to make a decision. There are cases where I almost denied a change initially, then realized Claude's approach made sense once I saw the full change set. Conversely, there are cases where I definitely should have stopped Claude earlier.
It doesn't help that Claude usually describes its changes after it has made the full series, instead of before.
...really, what I'd like is an easy way to go back in time, wherein going back to an earlier point in the conversation also reverted the state of the code. I can and do simulate this with git to some extent, but I'd prefer it as a layer on top of git. I want to use git to track other things.
Tell us what you do—how, under what conditions, and in which programming languages. What exactly makes it better? Does it just search for files? Well, that’s hardly objective.
So far the impression is… well, you say it only seems better. But you won’t get far with that kind of reasoning.
Objectively, it now seems to me that Claude the cat is better, because everyone around says it’s better. Yet no one has actually explained why. So the hype is inflated out of thin air, and there are no objective reasons for it.
It's less about writing code, more about building an engine that codes. It's hands off but unlike Cursor, it's not as eyes-off. You do observe and interrupt it. It is great for full on TDF - it figures out the feature, writes the test for the feature, fails the test, rewrites the code to pass. But at some point, you realize you got the instructions wrong and because you're outside the loop, you have to interrupt it.
I think it's a natural progression, but it's not for everyone. The people who hated not being able to write functions will hate claude code even more. But some people love writing their engines.
The key take away here is that save for the deep integration, there is a strategy for working with a best in class agent solution agnostic of tooling.
These learnings will eventually coalesce into "best practices" that people will apply using the editor or IDE of their choice and all these vscode forks will have died off.
Microsoft/GitHub has even signaled confidence that they can compete feature by feature with the forks by even open sourcing much of the Copilot integration in VS Code.
Aesthetically, I like VS Code Copilot/Copilot Chat UIs/UX for the most part, certainly better than I like Claude Code and more than I like Cursor, too.
I’m curious what this means:
> run it on a large, complex TypeScript codebase
What do you mean by “run it?”
Are you putting the entire codebase all at once into the context window? Are you giving context and structure prompts or a system architecture first?
Most of the people I see fail to “get” GPT assistants is because they don’t give context and general step-by-step instructions to it.
If you treat it like a really advanced rubber duck it’s straight up magic but you still have to be the senior engineer guiding the project or task.
You can’t just dump a 10,000 LOC file into it ask some vague questions and expect to get anything of value out of it.
I ended up with 8k lines of rust and 12k lines of markdown. I think those markdown designs and explicit tasks were required the same way unit tests with a test harness are required to make the human-tool interaction work.
However, I’m not sure if the ‘magic’ is VC-subsidy or something else.
It did make rust (a language i do not know) feel like a scripting language. … the github repo is ‘knowseams’.
that's supposed to be part of CS101
For new projects, I find Claude Code extremely helpful, as I start out with a business document, a top-level requirements document, and go from there. In the end (and with not a lot of work or time spent) I have a README, implementation plan, high-level architecture, milestones, and oftentimes a swagger spec, pipeline setup and a test harness.
IMHO pointing CC at a folder of a big typescript project is going to waste a ton of compute and tokens, for minimal value. That is not a good use of this tool. I also have a pretty strong opinion that a large, complex typescript codebase is a bad idea for humans too.
Point CC at a python or go repo and it is a whole 'nother experience. Also, starting out is where CC really shines as stated above.
For a big complex typescript repo I would want very specific, targeted help as opposed to agentic big-picture stuff. But that also minimizes the very reason I'd be reaching for help in the first place.
In that context, CC is amazing.
Cursor has an amazing tab completion model. It uses a bunch of heuristics to try to understand what you're doing and accelerate it. It's a bit like a very advanced macro engine, except I don't have to twist my brain into a pretzel trying to program my editor - it just works, and when it doesn't I press Esc, which takes about half a second. Or I reach for the agentic mode, where the iteration cycle is more like 30 seconds to a minute.
With the fully agentic editors, it takes more like 15 to 30 minutes, and now it's a full on interruption in my flow. Reviewing the agent's output is a chore. It takes so much more mental bandwidth than the quick accept/reject cycle in the editor. And I have to choose between giving it network access (huge security hazard) or keeping it offline (crippling it in most codebases).
I find that for throwaway codebases where I don't care about maintenance/security/reliability, I can put up with this. It's also incredibly useful when working with a language or framework that I don't fully understand (but the model understands better). But for most of my work it produces poor results and ends up being a net negative for productivity - for now.
I'm sure this will improve, but for now I consistently get better results in Cursor.
I have a monorepo, so different instructions and rules live in different corners of it, which I manually add as needed. Doing all this with Claude is hard: it kind of works, but it’s a kludge. It’s much easier to manage through the UI. As the saying goes, it’s better to see something once than to remember it ten times, type a command, and configure it.
I can say the same about Vim and Emacs users. No one has yet proven to me they can code and navigate faster than an ordinary programmer using a trackpad or a mouse and keyboard. It’s purely a matter of taste. I’ve noticed that people who love those tools are just bored at work and want to entertain their brains. That’s neither good nor bad, but it doesn’t give a real boost.
By the way, there’s a study (a bit old, admittedly) showing that working with an LLM still doesn’t provide a massive speed-up in programming. Yes, it spits out code quickly, but assembling a finished result takes much longer: you have to review, polish, start over, throw things out, start again. It’s not that simple.
Speaking of Claude, he’s a real master at shitting in the code. At the speed of sound he generates a ton of unnecessary code even when you ask him not to. You ask for something minimalist, nothing extra—he still slaps on a pile of code with useless tests that outsmart themselves and don’t work.
That’s the downside. Overall, it’s easier to program when you just say what to do instead of sitting there straining your own brain. But even then it’s not simple. If you yourself haven’t figured out very carefully what you’re doing, you’ll end up with crap. I almost always throw away what I wrote with an LLM when I was tired. I don’t think there’s ever been an exception.
The only way to write something decent is to dig in thoroughly: draw diagrams, write everything out, and only then tell the LLM exactly what to do. Then double-check, make sure it didn’t write anything extra, delete the excess. And only like that, in small chunks. The “make me a feature, I pressed a button and walked away” mode doesn’t work if the task is even slightly complex.
Yeah, I got carried away—had to let it out. I have a lot to say about LLMs and programming with them, and not just about Cursor and Claude. The tools completely upended the way we program...
I too notice this about Claude, I've written commands, massaged Claude.md, even hooks. Given it very precise feature guides. I see the same issues you do. Feels like Claude has a lazy lever built in to it.
I play GPT O3 off it constantly, it takes the spec, a repomix slice of the Claude work and gives a new gap.md for Claude to pursue. Rinse and repeat. It works but your cursor flow seems better.
My highest velocity was about 1.6 fib complexity points a day over thirty years, now it's 4.3 with Claude the last three weeks which is nuts. I'm a total hack, I think I could get it up to nine if I was a bit more organized. Probably won't have to, just wait for the next iteration of the Claude models.
Context is key, so it is also really helpful having a CLAUDE.md file; the /init command can create one for you.
If you are going to use it for generation (writing code); plan mode is a must. Hit shift-tab twice.
Finally; I'm mostly using the claude 4 sonnet model, but make sure to tell it to "ultrathink" (use those words); this means it can use more thinking tokens.
The whole thing looks like one large source of friction.
I've been using Cursor a lot and it speeds up everything for me. Not sure what kind of benefit Claude Code would give me.
Having an agent completely design/write a feature still feels weird. I like everything being hand written, even if I actually just tab completed and edited it slightly
That does net out to meaning that Cursor gets used way more often, atm.
You are absolutely right. A large portion are influencers (I would estimate around 95% of those you see on YouTube and forums) that are full of hype. I think most are not affiliated with Anthropic or any vendor, they are just trying to sell a course, ebook or some "get rich with AI" scheme.
What I appreciate about Claude Code:
- Since it is a terminal/CLI tool it can be run headlessly from cron jobs or scripts. This makes it easy to automate.
- I appreciate the predictable pricing model. A flat monthly fee gives me access to Claude Sonnet and Opus 4 in five-hour sessions each with its own usage limit that resets at the start of a new session. There is a fair use policy of around 50 sessions per month, but I haven’t hit that yet. I deliberately run only one instance at a time as I prefer to use it responsibly unlike some of the "vibe" influencers who seem to push it to the limit.
That's it. Despite being a CLI based tool, Claude Code is remarkably out of the box for what it offers.
That said, no coding agent I have encountered can fully ingest a large inconsistent legacy codebase especially one with mixed architectures that accumulated over years. This limitation is mainly due to context size constraints, but I expect this to improve as context windows grow.
I also suspect a lot of this is paid for or just terminal die hards.
Claude Code + Cursor is my setup. Claude Code is my workhorse that I use for most tasks.
For small tiny quick changes, I use Cursor in auto.
For architecture consulting I use Cursor chat with Grok 4.
Claude Code is much better at banging out features than Cursor’s Claude. And Claude itself is better than other models as a coding workhorse.
All that said: while we may all code, we are building wildly different things that have much different specific problems to solve so it doesn’t surprise me that there isn’t a universal setup that works best for everybody.
I think people just need to try a bunch to be honest. I think that we will get to a point (or are already there) where some models just resonate better with you and your communication (prompt) style.
But after using a bunch...I have to say that Gemini 2.5 Pro is consistently the best one I've used yet. It's pricey, but it just works.
I'm still looking for a good local model, but it's just going to be a while until anything local can match Gemini. It will eventually I think, but it'll take some time.
I probably won't be using Claude Code, but I'm glad it works for some folks.
The reason why they like Claude Code specifically over Cursor isn't because they were fans of terminal windows; on the contrary, its because CC is simpler. Cursor is complicated, and its interface communicates to the user that eventually you might be grabbing the wheel. Of course, experienced engineers want to grab the wheel; working together with the AI toward some goal. But these CC-stans don't. All that extra stuff in the UI scares them, because they wouldn't know what to do with it if they had to do something with it.
Its this particular kind of person that's also all over /r/ClaudeAI or /r/Cursor complaining about rate limits. If you've ever used these products, you'd realize very quickly: The only way you're hitting rate limits so quickly on the paid plans is if the only code that's being outputted is from the AI, nonstop, for eight hours a day, using only the most expensive and intelligent models. The only people who do this are the people who have no brain of their own to contribute to the process. Most CC/Cursor users don't hit rate limits, because they're working with the AI, like a tool, not managing it like a direct report.
Re: usage of LLMs, that is honestly the way I like to use LLMs. That and auto-complete.
It's great for creating a bird's-eye view of a project because that is very fuzzy and no granular details are needed yet. And it's great at being fancy autocomplete, with its stochastic bones. But the middle part where all the complexity and edge cases are is where LLMs still fail a lot. I shudder for the teams that have to PR review devs that jubilantly declare they have "5x'ed" their output with LLMs, senior or not.
What is even more worrisome is that the brain is a muscle. We have to exercise it with thinking, hence why puzzlers stay sharp at old age. The more you outsource your code (or creative writing) thinking, the worse you get at it, and the more your brain atrophies. You're already seeing it with Claude Code, where devs panic when they hit the limit because they just might have to code unassisted.
Lesson learned: being lazy with AI has a hidden cost.
On small issues it's usually just a glance over the diff, on harder issues it's not challenging to scold it into a good path once something starts coming together, as long as it's a localized edit with a problem I understand. I'll often take over when it's 40-60% there, which is only possible b/c it does a good job of following todo lists.
I've moved into a good daily workflow that emphasizes my own crafting during the times I'm sharp like mornings, and lets AI do the overtime and grunt work while I prepare for tomorrow or do more thoughtful writing and design.
I spend probably 70% of my active coding time coding. The rest is using LLMs to keep making progress but give my brain a bit of a break while I recharge, being more supervisory with what's happening, and then taking over if necessary or after the 10-15 minutes it takes for me to start caring again.
It gave me a shit plan today. Basically I asked it to refactor a block of prototype code that consisted of 40 files or so. It went the wrong way and tried to demolish it from the bottom up instead of making it 100% backwards compatible. If it made a mistake we would have taken forever to debug it.
But yeah, it gave me something to attack. And the plan was fixed within an hour. If I tried to make one myself, I would have frozen from the complexity or gone in circles documenting it.
Having the AI just getting the wheels turning when I'm not in the mood myself has many times been a good way to make progress.
If you haven’t tried it, I can’t recommend it enough. It’s the first time it really does feel like working with a junior engineer to me.
And I reach for Claude quite a bit because if it worked as well for me like everyone here says, that would be amazing.
But at best it’ll get a bunch of boilerplate done after some manual debugging, at worst I spend an hour and some amount of tokens on a total dead end
I sympathize with both experiences and have had both. But I think we've reached the point where such posts (both positive and negative) are _completely useless_, unless they're accompanied with a careful summary of at least:
* what kind of codebase you were working on (language, tech stack, business domain, size, age, level of cleanliness, number of contributors)
* what exactly you were trying to do
* how much experience you have with the AI tool
* is your tool set up so it can get a feedback loop from changes, e.g. by running tests
* how much prompting did you give it; do you have CLAUDE.me files in your codebase
and so on.
As others pointed out, TFA also has the problem of not being specific about most of this.
We are still learning as an industry how to use these tools best. Yes, we know they work really well for some people and others have bad experiences. Let's try and move the discussion beyond that!
I'd definitely watch Boris's intro video below [1]
[1] Boris introduction: https://www.youtube.com/watch?v=6eBSHbLKuN0 [2] summary of above video: https://www.nibzard.com/claude-code/
Clear instructions go a long way, asking it to review work, asking it to debug problems, etc. definitely helps.
It would have been a half-day worth of adventure at least should i have done it myself (from diagnosing to fixing)
When it drops in something hacky, I use that to verify the functionality is correct and then prompt a refactor to make it follow better conventions.
When it creates a bunch of useless junk I feel free to discard it and either try again with clearer guidelines (or switch to Opus).
The quality of the generated code is inversely proportional to the time it take to generate it. If you let Claude Code work alone for more than 300 seconds you will receive garbage code. Take that as a hint, if it can't finish the task in this time it means you are asking too much. Break up your feature and try with a smaller feature.
This seems consistent with some of the more precocious junior engineers I've worked with (and have been, in the past.)
Much less context babysitting too. Claude code is really good at finding the things it needs and adding them to its context. I find Cursor’s agent mode ceases to be useful at a task time horizon of 3-5 minutes but Claude Code can chug away for 10+ minutes and make meaningful progress without getting stuck in loops.
Again, all very surprising given that I use sonnet 4 w/ cursor + sometimes Gemini 2.5 pro. Claude Code is just so good with tools and not getting stuck.
I have mixed feelings; because this means there’s really no business reason to ever hire a junior; but it also (I think) threatens the stability of senior level jobs long term, especially as seniors slowly lose their knowledge and let Claude take care of things. The result is basically: When did you get into this field, by year?
I’m actually almost afraid I need to start crunching Leetcode, learning other languages, and then apply to DoD-like jobs where Claude Code (or other code security concerns) mean they need actual honest programmers without assistance.
However, the future is never certain, and nothing is ever inevitable.
I keep being told that $(WHATEVER MODEL) is the greatest thing ever, but every time I actually try to use them they're of limited (but admittedly non-zero) usefulness. There's only so many breathless blogs or comments I can read that just don't mesh with the reality I personally see.
Maybe it's sector? I generally work on Systems/OS/Drivers, large code bases in languages like C, C++ and Rust. Most larger than context windows even before you look at things like API documentation. Even as a "search and summarizer" tool I've found it completely wrong in enough cases to be functionally worthless as the time required to correct and check the output isn't a saving. But they can be handy for "autocompletion+" - like "here's a similar existing block of code, now do the same but with (changes)".
They generally seem pretty good at being like a template engine on non-templated code, so thing like renaming/refactoring or similar structure recognition can be handy. Which I suspect might also explain some of those breathless blog posts - I've seen loads which say "Any non-coder can make a simple app in seconds!" - but you could already do that, there's a million "Simple App Tutorial" codebases that would match whatever license you want, copy one, change the name at the top and you're 99% of the way to the "Wow Magic End Result!" often described.
aren't these people your seniors in the coming years? Its healthy to model an inflow and outflow.
Then they'll just get a contract to spin up a DoD-secure variant: https://www.anthropic.com/news/anthropic-and-the-department-...
People have such widely varying experiences and I’m wondering why.
It's also another in my growing list of data points towards my opinion that if an author posts meme pictures in their article, it's probably not an article I'm interested in reading.
The tools really do shine where they're good though. They're amazing. But the moment you try to do the more "serious" work with them, it falls apart rapidly.
I say this as someone that uses the tools every day. The only explanation that makes sense to me is that the "you don't get it, they're amazing at everything" people just aren't working on anything even remotely complicated. Or it's confirmation bias that they're only remembering the good results - as we saw with last week's study on the impact of these tools on open source development (perceived productivity was up, real productivity was down). Until we start seeing examples to the contrary, IMO it's not worth thinking that much about. Use them at what they're good at, don't use them for other tasks.
LLMs don't have to be "all or nothing". They absolutely are not good at everything, but that doesn't mean they aren't good at anything.
Not to dog the author too hard, but a look at their Github profile says a lot about the projects they've worked on and what kind of dev they are. Not much there in terms of projects or code output, but they do have 15k followers on Twitter, where they post frequently about LLMs to their audience.
They aren't talking about the tasks and the domains they're using because that's incidental; what they really want to do is just talk about LLMs to their online audience, not ship code.
It’s nice because 3/4 of those are well-known but not “default” industry choices and it still handles them very well.
So there’s a Laravel CRM builder called Filament which is really fun to work in. Claude does a great job with that. It’s a tremendous amount of boilerplate with clear documentation, so it makes sense that Claude would do well.
The thing I appreciate though is that CC as an agent is able to do a lot in one go.
I’ve also hooked CC up to a read-only API for a client, and I need to consume all of the data on that API for the transition to a Filament app. Claude is currently determining the schema, replicating it in Laravel, and doing a full pull of API records into Laravel models, all on its own. It’s been running for 10 minutes with no interruption and I expect will perform flawlessly at that.
I invest a lot of energy in prompt preparation. My prompts are usually about 200 words for a feature, and I’ll go back and forth with an LLM to make sure it thinks it’s clear enough.
I'd think Win32 development would be something AIs are very strong at because it's so old, so well documented, and there's a ton of code out there for it to read. Yet it still struggles with the differences between Windows messages, control notification messages, and command messages.
In my experience, LLMs are great at small tasks (bash or python scripts); good at simple CRUD stuff (js, ts, html, css, python); good at prototyping; good at documentation; okay at writing unit tests; okay at adding simple features in more complex databases;
Anything more complex and I find it pretty much unusable, even with Claude 4. More complex C++ codebases; more niche libraries; ML, CV, more mathsy domains that require reasoning.
E.g. I asked it to swap all on change handlers in a component to modify a use State rather than directly fire a network request, and then add on blurs for the actual network request. It didn't add use states and just added on blurs that sent network requests to the wrong endpoint. Bizarre.
I feel like working with Claude is what it must feel like for my boss to work with me. “Look, I did this awesome thing!”
“But it’s not what I asked for…”
But the other day I asked it to help add boundary logging to another legacy codebase and it produced some horrible, duplicated and redundant code. I see these huge Claude instruction files people share on social media, and I have to wonder...
Not sure if they're rationing "the smarts" or performance is highly variable.
There are some things in there that really take this from an average tool to something great. For example, a lot of people have no idea that it recognizes different levels of reasoning and allocates a bigger number of “thinking tokens” depending on what you ask (including using “ultrathink” to max out the thinking budget).
I honestly think that people who STILL get mostly garbage outputs just aren’t using it correctly.
Not to mention the fact that people often don't use Opus 4 and stay with Sonnet to save money.
I agree. It reminds me of this one junior engineer I worked with who produced awful code, and it would take longer to explain stuff to him than to just do it myself, let alone all the extra time I had to spend reviewing his awful PRs. I had hoped he would improve over time, but he took my PR comments personally and refused to keep working with me. At least Claude doesn't have an attitude.
If you want to try something better than claude code, try Cline.
My own experiments only show that this technology is unreliable.
If Claude is so amazing, could Anthropic not make their own fully-featured yet super-performant IDE in like a week?
If we are to believe the hype though, shouldn’t these tools be launching software into the stratosphere? Like the CEO of stripe said AI tools provide a x100 increase in productivity. That was 3-4months ago. Shouldn’t stripe be launching rockets in to space now since that’s technically 400months of dev time? Microsoft is reportedly all in on AI coding. Shouldn’t Teams be the best, most rock solid software in existence now? There is so much hype around these tools being a super charger for more than a year, but the actual software landscape looks kind of the same to me as it did 3-4 years ago.
I use it quite aggressively and I'd probably only estimate 1.5x on average.
Not world changing because we all mostly work on boring stuff and have endless backlogs.
And is this a good thing since you can (in theory) multitask and work longer hours, or bad because you're acquiring cognitive debt (see "Your Brain on ChatGPT")?
Or, as another commenter said, it's for investors, not developers, and certainly not the scum users.
80% (99%?) of what you hear about llms are from the first group, amplified by influencers.
I'm guessing people feel the productivity boost because documenting/talking to/guiding/prompting/correcting an LLM is less mentally taxing than actually doing the work yourself even though time taken or overall effort is the same. They underestimate the amount of work they've had to put in to get something acceptable out of it.
Ah, Stone Soup: https://en.wikipedia.org/wiki/Stone_Soup
I'm really not seeing these massive gains in my workflow either and maybe it's the nature of my general work but it's baffling how every use case for programming I'm seeing on YouTube is so surface level. At this point I've given up and don't use it at all
Not a "100x" boost, but a pretty good take on what tasks agents can do for even very good programmers.
Besides that, I think your best bet is to find someone on youtube creating something "live" using a LLM. Something like this: https://www.youtube.com/watch?v=NW6PhVdq9R8
i feel like some kind of shill, but honestly i'm anywhere from 1.5x to 10x on certain tasks. the main benefit is that i can reduce a lot of cognitive load on tasks where they are either 1) exploratory 2) throwaway 3) boilerplate-ish/refactor type stuff. because of that i have a more consistent baseline.
i still code "by hand". i still have to babysit and review almost all the lines, i don't just let it run for hours and try to review it at the end (nightmare). production app that's been running for years. i don't post youtube videos bc i don't have the time to set it up and try to disprove the "naysayers" (nor does that even matter) and its code i can't share.
the caveat here is we are a super lean team so probably i have more context into the entire system and can identify problems early on and head them off. also i have a vested interest in increasing efficiency for myself wheras if you're part of a corpo ur probably doing more work for the same comp.
This may sound more mean than I intend, but your comment is exactly the kind of thing the GP post was describing as useless yet ubiquitous.
By your own reckoning. There was that recent study showing how senior devs using AI thought they were 20% faster, when they were objectively 20% slower.
Deleted Comment
Here are some projects Claude has helped create:
1. Apache Airflow "DAG" (cron jobs) to automate dumping data from an on-prem PGSQL server to a cloud bucket. I have limited Python skills, but CC helped me focus on what I wanted to get done instead of worrying about code. It was an iterative process over a couple of days, but the net result is we now have a working model to easily perform on-prem to cloud data migrations. The Python code is complex with lots of edge conditions, but it is very readable and makes perfect sense.
2. Custom dashboard to correlate HAProxy server stats with run-time container (LXC) hooks. In this case, we needed to make sure some system services were running properly even if HAProxy said the container was running. To my surprise, CC immediately knew how to parse the HAProxy status output and match that with internal container processes. The net for this project is a very nice dashboard that tells us exactly if the container is up/down or some services inside the container are up/down. And, it even gives us detailed metrics to tell us if PGSQL replication is lagging too far behind the production server.
3. Billing summary for cloud provider. For this use case, we wanted to get a complete billing summary from our cloud provider - each VM, storage bucket, network connection, etc. And, for each object, we needed a full breakdown (VM with storage, network, compute pricing). It took a few days to get it done, but the result is a very, very nice tool that gives us a complete breakdown of what each resource costs. The first time I got it working 100%, we were able to easily save a few thousand $$ from our bill due to unused resources allocated long ago. And, to be clear, I knew nothing about API calls to the cloud provider to get this data much less the complexities of creating a web page to display the data.
4. Custom "DB Rebuild" web app. We run a number of DBs in in our dev/test network that need to get refreshed for testing. The DB guys don't know much about servers, containers, or specific commands to rebuild the DBs, so this tool is perfect. It provides a simple "rebuild db" button with status messages, etc. I wrote this with CC in a day or so, and the DB guys really like the workflow (easy for them). No need to Github tickets to do DB rebuilds; they can easily do it themselves.
Again, the key is focusing my energy on solving problems, not becoming a python/go/javascript expert. And, CC really helps me here. The productivity our team has achieved over the past few weeks is nothing short of amazing. We are creating tools that would require hiring expert coders to write, and giving us the ability to quickly iterate on new business ideas.
One trick I have gotten some milage out of was this: have Claude Code research Slash commands, then make a slash command to turn the previous conversation into a slash command.
That was cool and great! But then, of course you inevitably will interrupt it and need to do stuff to correct it, or to make a change or "not like that!" or "use this tool" or "think harder before you try that" or "think about the big picture" ... So you do that. And then you ask it to make a command and it figures out you want a /improve-command command.
So now you have primitives to build on!
Here are my current iterations of these commands (not saying they are optimal!)
https://github.com/ctoth/slashcommands/blob/master/make-comm...
https://github.com/ctoth/slashcommands/blob/master/improve-c...
A few small markdown documents and putting in the time to understand something interesting hardly seems a steep price!
I generally get great 1-shot (one input and the final output after all tasks are done) comments. I have moved past claude code though I am using the CLI itself with another model although I was using claude code and my reason for switching isn't that claude was a bad model it's just that it was expensive and I have access to larger models for cheaper. The CLI is the real power not the model itself per-se. Opus does perform a little better than others.
It's totally made it so I can do the code that I like to do while it works on other things during that time. I have about 60-70 different agent streams going at a time atm. Codebases sizes vary, the largest one right now is about 200m tokens (react, typescript, golang) in total and it does a good job. I've only had to tell it twice to do something differently.
I've only tried Claude Code with an external model once (Kimi K2) but it performed poorly.
The recent Kimi-K2 supposedly works great.
My own experience is that it is below sonnet and opus 4.0 on capability - but better than gemini 2.5 pro on tool calling. It's really worth trying if you don't want to spend the $100 or $200 per month on Claude Max. I love how succinct the model is.
> you can use CC with any model via
Anthropic should just open source Claude Code - they're in a position to become the VS Code of cli coding agents.
Shout out to opencode:
https://github.com/sst/opencode
which supports all the models natively and attempts to do what CC does
Edit: I see a sibling comment mention the Max plan. I wanna be clear that I am not talking about rate limits here but actual models being inaccessible - so not a rate limit issue. I hope Anthropic figures this out fast, because it is souring me on Claude Code a bit.
Here is an example of chat gpt, followed by mostly Claude that finally solved a backlight issue with my laptop.
https://github.com/mbrumlow/lumd
If you aren't sure whether to pull the trigger on a subscription, I would put $5-$10 into an API console account and use CC with an API key.