Today, I just saw this article about claude code and see that they added claude code to pro plan. But you will only get 10-40 prompts every 5 hours. What do you guys think?

Maybe you miss it:

Plan mode is a special operating mode in Claude Code that allows you to research, analyze, and create implementation plans without making any actual changes to your system or codebase.

What Plan Mode Does:

Research & Analysis Only:

• Read files and examine code

• Search through codebases

• Analyze project structure

• Gather information from web sources

• Review documentation

No System Changes:

• Cannot edit files

• Cannot run bash commands that modify anything

• Cannot create/delete files

• Cannot make git commits

• Cannot install packages or change configurations

When Plan Mode Activates:

Plan mode is typically activated when:

• You ask for planning or analysis before implementation

• You want to understand a codebase before making changes

• You request a detailed implementation strategy

• The system detects you want to plan before executing

How It Works:

1. Research Phase: I gather all necessary information using read-only tools

2. Plan Creation: I develop a comprehensive implementation plan

3. Plan Presentation: I use the exit_plan_mode tool to present the plan

4. User Approval: You review and approve the plan

5. Execution Phase: After approval, I can proceed with actual implementation

Benefits:

• Safety: Prevents accidental changes during exploration

• Thorough Planning: Ensures comprehensive analysis before implementation

• User Control: You approve exactly what will be done before it happens

• Better Outcomes: Well-planned implementations tend to be more successful

I Work with a small team on a startup that at this point needs a lot of work especially since we got a "cash injection" from investors. At this moment we all work 10-12h daily and sometimes on weekends to deliver the MVP in time. Project is new, so we dont have a lot of files. From the models Google and Claude are doing the best with Claude Code in terms of usage and collaboration. I'm thinking about a subscription but I don't know what's worth choosing and if it's worth choosing Claude. Here I point out that I don't want to use API keys or Cursor, because I happened to use as much as $100-200 a day, and I would prefer to have limits in the back of my mind so that I don't rely only on this one model for everything. With api keys I often like to push the maximum consumption so for my sake and budget I prefer to pay one fixed price per month.

Just what to choose, what plan, for how much?Is the claude code worth it or can I buy a subscription somewhere else with access to claude? I would like to ask for your help

Hey everyone,
I’ve been using Cursor, but I already hit the usage limit halfway through the month, even though I’m actually coding less than before their pricing change.

I’m thinking of switching to Claude Code. For those using it, is the $20/month plan enough for your regular coding needs?

For context, I’m a full-on vibe coder. I do everything with AI and rely on it heavily. So I’m curious if Claude can keep up with that style of workflow.

Any insights would be appreciated!

Hey r/ClaudeAI (and fellow devs!), Been diving deep into whether Anthropic's Max plans ($100/mo for "5x Pro" & $200/mo for "20x Pro") actually make sense if you're hammering away at the Claude Code terminal tool. Wanted to share my thoughts and a bit of a cost comparison against just using the API directly (for Code, Sonnet, and Opus). TL;DR: If you're a heavy, daily user of Claude Code (and Claude generally), especially if you want that sweet Opus power in Claude Code without the eye-watering Opus API prices, Max plans can be a great deal. For casual or light users, sticking with the API is probably still your best bet. So, How Do Max Plans Even Work with Claude Code? First off, your usage limits on Max plans are shared between your normal Claude chats (web/app) and whatever you do in Claude Code. It all comes from the same bucket.

• Max Plan $100 (they call it "5x Pro"):

  • You get roughly 50-200 prompts in Claude Code every 5 hours.

  • Access to both Sonnet 4 and the mighty Opus 4 within Claude Code. BUT, here's the catch: Opus will automatically flip over to Sonnet once you've used up 20% of your 5-hour limit with Opus.

• Max Plan $200 (the "20x Pro" beast):

  • A hefty 200-800 prompts in Claude Code every 5 hours.

  • Same deal: Sonnet 4 and Opus 4 access. For this tier, Opus switches to Sonnet after you burn through 50% of your 5-hour limit on Opus.

• And don't forget, Opus chews through your limits about 5 times faster than Sonnet does. Quick API Cost Refresher (per 1 million tokens):

• Claude Code (via API - it's Sonnet-based + "thinking tokens"):

  • Input: ~$3 / Output: ~$15 (that output cost includes "thinking tokens," which can make it pricier than you'd think for complex stuff).

• Claude Sonnet 4 API (direct):

  • Input: $3 / Output: $15.

• Claude Opus 4 API (direct - hold onto your wallet!):

  • Input: $15 / Output: $75. When Do Max Plans Actually Become "Worth It" for Claude Code?

• You're a Coding Machine (Daily, Heavy Use): If you're constantly in Claude Code and also using Claude for other tasks (writing, research, brainstorming), that $100 or $200 monthly fee might actually be cheaper than what you'd rack up in API fees.

  • Some reports suggest "moderate" daily Claude Code API use can hit $20-$40. If that's your baseline, the Max $100 plan (which works out to about $3.33/day) starts looking pretty good.

• You Crave Opus in Claude Code (Without Selling a Kidney): Getting Opus access within the Max plans is a massive cost saving compared to paying the direct Opus API rates. Even with the usage caps on Opus within the plan, it's a much more affordable way to tap into its power for those really tricky coding problems.

• You Like Knowing What You'll Pay: Fixed monthly cost. No surprise API bills that make your eyes water. Simple. When Might Sticking to the API Be Smarter?

• Light or Occasional Coder: If you only fire up Claude Code once in a blue moon, a $100/month subscription is probably overkill. Pay-as-you-go API is your friend.

• You Need Unrestricted Opus (and have deep pockets): If your workflow demands tons of continuous Opus through Claude Code, the Opus limits within the Max plans might still feel restrictive, and you might end up needing the pricey Opus API anyway.

• You're an API Cost-Saving Wizard: If you're savvy enough to properly implement and benefit from API features like prompt caching (can save up to 90%) or batch processing (50% off), you might be able to get your API costs lower than a Max plan. Heads-Up on a Few Other Things:

• Shared Limits are Key: Seriously, remember that Claude Code and regular Claude chat dip into the same 5-hour usage pool.

• Auto Model Downgrade: That switch from Opus to Sonnet in Claude Code on Max plans is automatic when you hit those percentage thresholds. It's not unlimited Opus all the time.

• "Thinking Tokens" Can Bite: If you use Claude Code via the API (like if your plan runs out and you opt into API credits), it's billed like Sonnet, but those "thinking tokens" for complex agentic tasks can add up.

• The ~50 Sessions/Month "Guideline": For Max plans, Anthropic mentions a "flexible guideline" of about 50 five-hour sessions a month. They say most people won't hit this (it's like 250 hours!), but if you're an extreme user, it's something to be aware of as they might impose limits. My Takeaway: It really boils down to your specific workflow. If you're a Claude Code power user, especially one who benefits from Opus, the Max plans offer genuine value and can save you money. For everyone else, the API's flexibility and pay-for-what-you-use model is probably still the way to go. Hope this breakdown helps someone out there trying to decide! What are your experiences with Max plans or Claude Code costs? Drop a comment!

Hey all, quick question. for real dev work, is the $100 plan enough in practice or do you really feel the $200 tier? also, how does sonnet compare to opus for coding. appreciate any real world takes.

Hi everyone, I'm a developer who has been using Claude Code Max ($200 plan) for 3 months now. With renewal coming up on the 21st, I wanted to share my honest experience.

Initial Experience (First 1-2 months): I was genuinely impressed. Fast prototyping, reasonable code architecture, and great ability to understand requirements even with vague descriptions. It felt like a real productivity booster.

Recent Changes I've Noticed (Past 2-3 weeks):

1. Performance degradation: Noticeable drop in code quality compared to earlier experience

2. Unnecessary code generation: Frequently includes unused code that needs cleanup

3. Excessive logging: Adds way too many log statements, cluttering the codebase

4. Test quality issues: Generates superficial tests that don't provide meaningful validation

5. Over-engineering: Tends to create overly complex solutions for simple requests

6. Problem-solving capability: Struggles to effectively address persistent performance issues

7. Reduced comprehension: Missing requirements even when described in detail

Current Situation: I'm now spending more time reviewing and fixing generated code than the actual generation saves me. It feels like constantly code-reviewing a junior developer's work rather than having a reliable coding partner.

Given the $200/month investment, I'm questioning the value proposition and currently exploring alternative tools.

Question for the community: Has anyone else experienced similar issues recently? Or are you still having a consistently good experience with Claude Code?

I'm genuinely curious if this is a temporary issue or if others are seeing similar patterns. If performance improves, I'd definitely consider coming back, but right now I'm not seeing the ROI that justified the subscription cost.

Claude Code has just stealthily integrated a plan mode by hitting shift+tab once more after enabling auto-updates. No files editable, purely read & think. No documentation or release notes anywhere yet, as far as I can see.

Likely based on this GitHub issue (and other demand) https://github.com/anthropics/claude-code/issues/982

I know, I probably shouldn't say anything because this is absolutely subsidized launch pricing to drive up interest and I'm going to jinx it and they'll eventually slow down the gravy train but damn. I saw someone else post their $20 in 2 days breaking even and thought I might as well share my own experience - I broke even day 1. I've actually only gotten rate limited once, and it was for about an hour and a half on that first day when I burned $30 in equivalent API use.

I'm a heavy roo code user via API and get everything for free at work so I generally look for the right tool for the job more than anything else, and while I still think roo modes shine where claude code hasn't quite nailed yet, it's a very solid product. In my own time, I had been going more gemini heavy in roo because sonnet struggles with big context and have mad love for that beautiful month of free 2.5 pro exp... and I was willing to overlook a lot of the 05-06 flaws. Jury is still out on 06-05, but I decided to give the $20 plan a shot and see if claude code would cut my API bills and damn. It did almost immediately. First day was 06/06, the 06/01 and 06/05 were using my direct anthropic API. This is not an ad, it's good shit and you might as well get some VC funded discount claude code usage while it's still out there.

can CC default to creating plans in the project's local .claude folder, not the higher level ~\.claude\plans folder?

Using VSCode with Claude Code extension, sonnet 4.5, pro plan.

What really works

• State GOALS in clear plain words - AI can't read your mind; write 1‑2 lines on what and why before handing over the task (better to make points).

• PLAN before touching code - Add a deeper planning layer, break work into concrete, file‑level steps before you edit anything.

• Keep CONTEXT small - Point to file paths (/src/auth/token.ts, better with line numbers too like 10:20) instead of pasting big blocks - never dump full files or the whole codebase.

• REVIEW every commit, twice - Give it your own eyes first, then let AI reviewer catch the tiny stuff.

Noise that hurts

• Expecting AI to guess intent - Vague prompts yield vague code (garbage IN garbage OUT) architect first, then let the LLM implement.

  • "Make button blue", wtf? Which button? properly target it like "Make the 'Submit' button on /contact page blue".

• Dumping the whole repo - (this is the worst mistake i've seen people doing) Huge blobs make the model lose track, they dont have very good attention even with large context, even with MILLION token context.

• Letting AI pick - Be clear with packages you want to use, or you're already using. Otherwise AI would end up using any random package from it's training data.

• Asking AI to design the whole system - don't ask AI to make your next 100M $ SaaS itself. (DO things in pieces)

• Skipping tests and reviews - "It compiles without linting issues" is not enough. Even if you don't see RED lines in the code, it might break.

My workflow (for reference)

• Plan

  • I've tried a few tools like TaskMaster, Windsurf's planning mode, Traycer's Plan, Claude Code's planning, and other ASK/PLAN modes. I've seen that traycer's plans are the only ones with file-level details and can run many in parallel, other tools usually have a very high level plan like -"1. Fix xyz in service A, 2. Fix abc in service B" (oh man, i know this high level thing myself).

  • Models: I would say just using Sonnet 4 for planning is not a great way and Opus is too expensive (Result vs Cost). So planning needs a combination of good SWE focused models with great reasoning like o3 (great results as per the pricing now).

  • Recommendation: Use Traycer for planning and then one-click handoff to Claude Code, also helps in keeping CC under limits (so i dont need 200$ plan lol).

• Code

  • Tried executing a file level proper plan with tools like:

    • Cursor - it's great with Sonnet 4 but man the pricing shit they having right now.

    • Claude Code - feels much better, gives great results with Sonnet 4, never really felt a need of Opus after proper planning. (I would say, it's more about Sonnet 4 rather than tool - all the wrappers are working similarly on code bcuz the underlying model Sonnet 4 is so good)

  • Models: I wouldn't prefer any other model than Sonnet 4 for now. (Gemini 2.5 Pro is good too but not comparable with Sonnet 4, i wouldn't recommend any openai models right now)

  • Recommendation: Using Claude Code with Sonnet 4 for coding after a proper file-level plan.

• Review

  • This is a very important part too, Please stop relying on AI written code! You should review it manually and also with the help of AI tools. Once you have a file level plan, you should properly go through it before proceeding to code.

  • Then after the code changes, you should thoroughly review the code before pushing. I've tried tools like CodeRabbit and Cursor's BugBot, i would prefer using Coderabbit on PRs, they are much ahead of cursor in this game as of now. Can even look at reviews inside the IDE using Traycer or CodeRabbit, - Traycer does file level reviews and CodeRabbit does commit/branch level. Whichever you prefer.

  • Recommendation: Using CodeRabbit (if you can add on the repo then better to use it on PRs but if you have restrictions then use the extension).

Hot take

AI pair‑programming is faster than human pair‑programming, but only when planning, testing, and review are baked in. The tools help, but the guard‑rails win. You should be controlling the AI and not vice versa LOL.

I'm still working on refining more on the workflow and would love to know your flow in the comments.

Hey everyone,

I’m new to Claude code and just subscribed to the $20 plan. I’d love to hear your tips and best practices for using Claude code and the regular chat effectively—especially when it comes to optimizing workflows and avoiding unnecessary token usage. Any advice from regular users would be greatly appreciated!

Share your methods and tips!

After a few months using Claude Code, I ended up developing a somewhat different workflow that’s been working really well. The basic idea is to use two separate Claudes - one to think and another to execute.

Here’s how it works:

Claude Desktop App: acts as supervisor. It reads all project documentation, analyzes logs when there’s a bug, investigates the code and creates very specific prompts describing what needs to be done. But it never modifies anything directly.

Claude Code CLI in VS Code: receives these prompts and does the implementations. Has full access to the project and executes the code changes.

My role: is basically copying prompts from one Claude to the other, running tests and reporting what happened.

The flow in practice goes something like this: I start the session having Claude Desktop read the CLAUDE.md (complete documentation) and the database schema. When I have a bug or new feature, I describe it to Claude Desktop. It investigates, reads the relevant files and creates a surgical prompt. I copy that prompt to Claude Code which implements it. Then Claude Desktop validates by reading each modified file - it checks security, performance, whether it followed project standards, etc. If there’s an error in tests, Claude Desktop analyzes the logs and generates a new correction prompt.

What makes this viable: I had to create some automations because Claude Code doesn’t have native access to certain things:

1. CLAUDE.md - Maintains complete project documentation. I have a script that automatically updates this file whenever I modify code. This way Claude Desktop always has the current context.

2. EstruturaBanco.txt - Since Claude Code doesn’t access the database directly, this file has the entire structure: tables, columns, relationships. Also has an update script I run when I change the schema.

3. Log System - Claude CLI and Code Desktop don’t see terminal logs, so I created two .log files (one for frontend, another for backend) that automatically record only the last execution. Avoids accumulating gigabytes of logs and Claude Desktop can read them when it needs to investigate errors.

Important: I always use Claude Code Desktop in the project’s LOCAL folder, never in the GitHub repository. Learned this the hard way - GitHub’s cache/snapshot doesn’t pick up the latest Claude CLI updates, so it becomes impossible to verify what was recently created or fixed.

About the prompts: I use XML tags to better structure the instructions like: <role>, <project_context>, <workflow_architecture>, <tools_policy>, <investigation_protocol>, <quality_expectations>. Really helps maintain consistency and Claude understands better what it can or can’t do.

Results so far: The project has 496 passing unit tests, queries running at an average of 2.80ms, and I’ve managed to keep everything well organized. The separation of responsibilities helps a lot - the Claude that plans isn’t the same one that executes, so there’s no context loss.

And you, how do you use Claude Code day-to-day? Do you go straight to implementation or do you also have a structured workflow? Does anyone else use automation systems to keep context updated? Curious to know how you solve these challenges.​​​​​​​​​​​​​​​​

Hi!

Never used Claude Code before, but since I am spending so much on Cursor now, the Claude plan actually looks appealing. How is the quality of code? Context window? Etc etc. I am not vibe coding but I do use agents intensively by reiterating and asking questions to validate certain approaches etc.

Claude Code has been running flawlessly for me by literally telling it to come up with a plan to make a change.

For example: "Think of a way to create a custom contact page for this website. Think of any potential roadblocks and or errors that may occur".

Then, I just take that output and paste it into Gemini, and tell it "Here is my plan to create a custom contact page for my website: [plan would go here]" (If you want to make it even better give it access to your code). Tell it to critique and make changes to this plan. Then you just feed the critiques back into Claude code and they go back and forth for a while until they both settle on a plan that sounds good.

Now you just tell Claude code "Implement the plan, make sure to check for errors as you go" and I have done this about 13 times and it has built and deployed, no extra debugging.

My team and I have been using AI coding assistants daily in production for months now, and we keep hearing the same split from other devs:

• “They’re game-changing and I ship 3× faster.”

• “They make more mess than they fix.”

One big variable that doesn’t get enough discussion: are you planning the AI’s work in detail, or just throwing it a prompt and hoping for the best?

We wanted to know how much that really matters, so we ran a small controlled test with Claude Code, Cursor, and Junie.

The Setup

I gave all three tools the exact same feature request twice:

1. No Planning — Just a short, high-level prompt with basic requirements detail.

2. With Planning — A detailed, unambiguous spec covering: product requirements, technical design and decisions, detailed tasks with context for each prompt.

We used our specialized tool (Devplan) to create the plans, but you could just as well use chatGPT/Claude if you give it enough context.

Project/Task

Build a codebase changes summary feature that runs on a schedule, stores results, and shows them in a UI.

Rules

• No mid-build coaching, only unblock if they explicitly ask

• Each run scored on:

  • Correctness — does it work as intended?

  • Quality — maintainable, follows project standards

  • Autonomy — how independently it got to the finish line

  • Completeness — did it meet all requirements?

Note that this experiment is low scale, and we are not pretending to have any statistical or scientific significance. The goal was to check the basic effects of planning in AI coding.

Results (Claude Code Focus)

Results Across All Tools for Context

What I Saw with Claude Code

• Correctness jumped from “mostly wrong” to “nearly production-ready” with a plan.

• Quality improved — file placement, adherence to patterns, and reasonable implementation choices were much better.

• Autonomy stayed maxed — Claude handled both runs without nudges, but with a plan it simply made fewer wrong turns along the way.

• The planned run’s PR was significantly easier to review.

Broader Observations Across All Tools

1. Planning boosts correctness and quality

   • Without planning, even “complete” code often had major functional or architectural issues.

2. Clear specs = more consistent results between tools

   • With planning, even Claude, Cursor, and Junie produced similar architectures and approaches.

3. Scope control matters for autonomy

   • Claude handled bigger scope without hand-holding, but Cursor and Junie dropped autonomy when the work expanded past ~400–500 LOC.

4. Code review is still the choke point

   • AI can get you to ~80% quickly, but reviewing the PRs still takes time. Smaller PRs are much easier to ship.

Takeaway

For Claude Code (and really any AI coding tool), planning is the difference between a fast but messy PR you dread reviewing and a nearly production-ready PR you can merge with a few edits

Question for the group:
For those using Claude Code regularly, do you spec out the work in detail before handing it off, or do you just prompt it and iterate? If you spec it out, what are your typical steps to get something ready for execution?

In Max 100$ subscription we get 5x the tokens compared to pro 20$ plan. But when we buy two pro plans it would get upto 80% of tokens of max plan. At 40% of cost. So cost vs usage which do you think is better?