Should you learn to code?

Some of my favorite childhood memories are of sitting in front of a tiny TV hooked up to my Commodore Vic-20 (with tape drive and 300 baud modem) making games and other apps in 1982.

Thirty years of freelance coding later, I still love doing it!

In early 2022, I started playing around with the Github Copilot extension in my VS Code way way back when it first came out and it’s “brain” was GPT-3.5 turbo. I was in the middle of a one-year “Senior Python Engineer” contract. After playing around with Copilot for a few hours, I was alarmed at how many short-sighted and just bad changes it wanted to make to my code. Uninstalled it. BUT when GPT-4 came out, I found that working with it on their web site was useful in helping me plan projects, tighten up already written code snippets, and increasingly, more.

Small but significant leap

A year later, both Github Copilot and LLMs improved enough that I found I was starting to x2 / x3 my productivity, with great care and many git commits and reverts.

Between then and now, I’ve seen steady increases in quality (usually in the underlying models, yay Claude 3.5 and now 3.7!) because real competition for Github Copilot took awhile to appear. And now, finally, there are quite a few high quality competitors for Github Copilot that in my opinion, blow it out of the water.

A new kind of assistant; hello agent

[skip this section if you are not a coder or technically nerdy]

The super-new batch are more “agentic” in nature, having more thinking-like planning capabilities.

I tried Cursor and Augment. A little about Cursor later. With Augment, though, I have a bone to pick: First, they want $30/month for their tool. Second, I was struggling to find how to swap out the underlying “brains” (LLM) it uses, so I went into their Discord to ask. The reply I got was a short explanation and link to a page on their site that basically says they do not provide a choice and yay “it’s a feature” because “developers face too many choices already.” With much badgering from me, their rep on discord finally revealed the underlying model they use is Claude 3.0 Opus, a model I consider now in 2025 to be obsolete, especially given 3.5 and 3.7 exist and are head and shoulders better.

So I moved on to try Cursor’s coding assistant’s free trial. It’s one of the new “agentic” coding assistants. Loved it! Noticed, though, that – of course – using their free trial didn’t get me very far. Didn’t love that Cursor was not available as an extension for VS Code but instead was an entire fork of VS Code but it did work fine. Just as I was about to pull the trigger on the $20/month pro plan, I stumbled upon a YouTuber raving about Cline. This was just over a week ago. And guess what? It’s free.

For an in-depth analysis of Cursor’s confusing and misleading pricing structure, scroll to the very bottom of this article.

Edit: Hearing really good things about Windsurf agentic coding assistant. Like Cursor, it uses a fork of VS Code and is similar to Cursor in many ways.

Cline – VS Code extension

My current love affair with Cline: I am enthralled by the variety of underlying LLM models I can have it use “under the covers.” Just yesterday, I found if I point it at OpenRouter as API provider, I can access Deepseek’s currently free v3, which is close to Claude 3.7 / GPT 4o1 in its intelligence and yeah, FREE. Right now, for the hard stuff, I switch to Claude 3.7 and turn on “enable extended thinking.”. Also, yeah, you can toggle “auto approve” on/off and just watch it go (think) with coming up with a plan of action. Once its plan is complete, it presents you with a detailed summary and you can tell it to modify the plan and/or just click “Act” and watch it go make changes across all the files in your code base it needs to change. You can even give it custom instructions on browser use and more. Oh and one “kinda nice” thing is that it shows you a running budget at the top of the screen for how much money you have spent with the various LLMs you have it using.

With the right underlying model, it can do a lot! And sure, yes, I still have to babysit and correct things often. But it is a huge improvement on Github Copilot. It’s basically a free version of Cursor, who charge $20/month and you can quickly run out of tokens because Cursor has to use your $20/month to pay the LLM providers like Anthropic, OpenAI (evil), Google (evil), et al. Even if Cursor has a bulk deal with those non-free LLM providers, it’s easy for them to start losing money. I predict they will either raise their prices or follow Cline’s model where you handle which LLM “brain” it uses and you pay for that use directly. Update: Apparently, with Cursor, it is a mix where you pay a base fee for level of membership, which gets you a certain amount of LLM token uses, and when that runs out, you can buy more.

Roo Code – VS Code extension

Edit 2025-04-04: Started hearing good things about Roo Code, an “agentic assistant” very similar to Cline, including that it is free.

I’ve installed the Roo Code extension in VS Code and it is much more flexible than Cline. Instead of two set modes, Plan and Act, it has many and they are customizable. With this kind of flexibility, I can see using Roo Code for far more than just coding! And you can set which underlying LLM to use for each mode separately, just like in Cline.

Which LLM brains to use in your coding agent?

Free models: Deepseek’s latest and Google’s latest (as of today it is Gemini Pro 2.5 experimental 03-25).

Paid models: Anthropic models (Claude 3.5 and 3.7) and OpenAI models (GPT4o, o1, etc).

Extrapolation time

OK so here we are now in March of 2025 and the average person does not realize a very important fact: these code assistants and LLM models are as dumb as they will ever be.

Many people are making great arguments for coding not going away and some actually believe government statistics/predictions saying demand for coding by humans will increase. Again, they seem to be assuming, though, that these assistants and LLMs (and what is coming post-LLM) will not improve. Even before we have the successor to the current LLM structure, we have seen since the start an increase in “intelligence,” math, general problem solving, creativity, larger context windows, planning capabilities, and more.

Right NOW the state of the art coding assistants/agents build small bug-free applications easily and quickly in one shot, meaning one prompt and boom the app is built within minutes.

Again, extrapolate. Have you noticed how rapidly new models are coming out that leapfrog the capabilities of old ones? Lately, weekly. Weekly!

Even taking a conservative view: significant jumps in capability at least every month! I predict that within 2 months, the size of a robust app that a coding agent (notice I’ve changed from calling them assistants?) will have doubled. And I predict that size will double again and again every 2-3 months, on average.

The writing is on the wall. This is not like when people feared the dominance of WordPress would put software engineers out of jobs. Just around the corner is the arrival of a new kind of software engineer that is cheaper, more emotionally resilient, and more physically resilient than a human. And yes, very very soon, more skilled than any human.

Learn to code?

Advice: If you have the time, sure, learn to code for the self-discipline, mental stimulation, leveling up your problem-solving skills, and general growth, not for future money/success.

Instead or in addition, learn how to use and communicate with LLMs. Sadly and excitedly, it’s a moving target. For example, prompting techniques right now will be obsolete in mere months as LLMs (and their successors) get so smart, it won’t matter how you phrase your requests.

The future is scary and the future is so bright I gotta wear shades (~ Tom Petty).

Getting the idea? It doesn’t stop there

“But ain’t no ai gonna repair cars like I do at my shop.” Ever heard of robots? If doctors are already using ai and ai-driven surgical robots being tested, then yes, human auto-mechanics will go obsolete at some point.

“I make music and you can tell when a song is made by AI. It will never be as good as humans.” Guess what? State of the art right now is pretty impressive and can even fool a non-trained ear. And they are improving monthly! I’m about to put out a music video that is composed of 15 ai-made songs. I wrote the lyrics but used one of the high end music generators to make the songs. Anyway, remember ASI (artificial super-intelligence)? ASI “musicians” will not only be able to produce music that convinces the best of musicians that it’s made by humans, but will go past that pretty quickly into a land we can’t quite see. I’m imagining music that will induce tears, laughter, and any other emotion IN SPITE OF YOU (your personality, your humor, your whatever).

And yes, that brings up another doomsday scenario. Imagine an ai so skilled at manipulating human emotions that… Yeah… some bad shtuff can happen.

Best outcome… For more of this kind of speculation about the near future:
https://clearsay.net/the-robot-in-the-room

I welcome all ideas, arguments, assertions of my brain being tiny or damaged, curses to my blood line, etc.

Some hypothetical/experimental potential post-LLM models: https://clearsay.net/next-generation-of-ai

OR watch the animated musical story / prediction of where things are going and how we get there:

A music video of the future by Scott Howard Swain

Cursor’s Subscription Tiers and Request-Based Pricing

Cursor AI operates on a tiered subscription model, as outlined on its official pricing page^[1]. The Pro tier ($20/month) provides 500 “fast premium requests” per month for models like GPT-4, Claude 3.5 Sonnet, and Gemini 2.5 Pro, alongside unlimited “slow premium requests.” The Business tier ($40/user/month) doubles the fast request quota to 1,000^[1]. These “requests” correspond to interactions with premium models (e.g., generating code completions, chat responses, or tool calls) rather than direct token quotas. For example, a single code-generation task involving multiple file edits might consume several requests due to iterative model interactions^[2]^[3].

However, the relationship between requests and tokens is indirect. While Cursor does not explicitly meter tokens for subscription users, token limits implicitly constrain usage. For instance:

The context window for models like GPT-4o is capped at 60,000 tokens in Cursor, significantly lower than the 128,000 tokens available via OpenAI’s API^[2].
Users report that large codebases or complex tasks quickly exhaust these limits, forcing frequent context resets and inflating request counts^[4]^[5].

Thus, while the subscription itself is request-based, token constraints indirectly ration usage.

Post-Subscription Costs: API Key Integration and Hidden Expenses

When users exceed their fast request quota, they face two options:

Unlimited slow requests: Lower-priority access to premium models, which may suffer latency during peak times^[1].
External API keys: Users can integrate their own OpenAI, Anthropic, or Gemini keys to bypass Cursor’s quotas entirely^[6]^[7].

The latter option introduces token-based pricing from third-party providers. For example:

Using Claude 3.5 Sonnet via an Anthropic API key costs ~$3 per million input tokens and $15 per million output tokens^[8].
A single code-review task involving 150,000 input tokens and 5,000 output tokens would cost approximately $0.45 + $0.075 = $0.525^[2].

This creates a hybrid cost structure: fixed subscription fees for baseline access and variable token-based expenses for heavy users. However, Cursor does not directly sell additional tokens; instead, users bear API costs independently.

“Buy More” Mechanism

Cursor offers no in-app token purchases. Instead, heavy users must:

Upgrade to a higher tier (e.g., Pro to Business for 1,000 fast requests)^[9].
Use external API keys, incurring separate per-token charges^[6]^[10].

For example, a Pro user who exhausts 500 fast requests might pay $0.50–$2.00 per task via their OpenAI key, whereas Cursor’s markup for equivalent usage under the subscription is estimated at 167%^[8].

Opaque Token Limits

Cursor’s documentation emphasizes request quotas but obscures token constraints. The GPT-4 context window is artificially limited to 60,000 tokens in Cursor versus 128,000 in the native API^[2], and users report confusion over whether token counts reset per request or accumulate globally^[4]^[5]. This lack of transparency exacerbates perceived costs, as tasks requiring large contexts demand more frequent requests.

Tool Call Overhead

Cursor’s “tool calls”—automatic model interactions for tasks like code refactoring—inflate usage. A single user-initiated request might trigger multiple backend tool calls, each consuming a request or token quota^[2]^[3]. For instance, a code-review task involving 86 tool calls could cost $720 via Cursor’s API integration, compared to $32 via a direct Gemini 2.5 Pro API^[2].

Comparative Cost Analysis

To illustrate the hybrid pricing model’s impact, consider a developer performing 1,000 premium model interactions per month:

Approach	Cost	Context Limit
Cursor Pro ($20)	500 fast + 500 slow requests	60,000 tokens^[2]
OpenAI API + Cursor Free	~$15 (1M tokens)	128,000 tokens^[2]
Claude API + Cursor Free	~$45 (1.5M tokens)	200,000 tokens^[11]

While Cursor Pro offers predictability, heavy users often find direct API integration cheaper despite losing access to Cursor-exclusive features like Tab autocomplete^[1]^[12].

User Sentiment and Criticisms

Perceived Nickel-and-Diming

Users criticize Cursor for:

Unpredictable tool calls: Automated model interactions that consume requests without explicit user consent^[2]^[5].
Arbitrary context limits: Restricting models like Gemini 2.5 Pro to 60,000 tokens despite their native 1M-token capability^[5].
Lack of transparency: Failing to clarify how requests map to tokens or tool calls^[4]^[13].

Competitive Pressure from DeepSeek

Open-source models like DeepSeek-R1 challenge Cursor’s value proposition. At $0.28 per million tokens, DeepSeek is ~143x cheaper than Cursor’s markup on Claude 3.5 Sonnet^[8]. Users argue Cursor must either reduce prices or offer DeepSeek integration to remain competitive^[14]^[8].

Conclusion

Subscriptions provide request quotas, not token allowances.
Token limits exist indirectly via context windows and tool calls.
Additional costs arise from third-party API usage, not in-app purchases.

For light users, Cursor Pro’s $20 fee offers convenience and predictability. However, heavy users face steep hidden costs from token-based API fees and opaque usage constraints. To retain power users, Cursor must improve transparency, adopt competitive models like DeepSeek, and decouple tool calls from request quotas.