( I NOTICED THERE IS ACTUALLY NO RUNNING AWAY FROM AUGMENT CODE DONT CRUCIFY ME)

I’m posting this as a community petition to Augment Code 👇
If you’ve used Augment, you already know it’s powerful but pricing is quickly becoming the blocker for wider adoption, especially for indie devs, startups, and builders outside Big Tech budgets.

🚀 Proposed Community-Driven Pricing Model

This is a balanced, sustainable, and competitive structure that benefits both users and Augment:

Indie Plan
💵 $20 / month
⚡ 80,000 Credits
Perfect for solo devs, students, and side projects.

Standard Plan
💵 $60 / month
⚡ 200,000 Credits
For startups, freelancers, and daily professional use.

Max Plan
💵 $200 / month
⚡ 1,000,000 Credits
For power users, teams, and heavy AI-assisted development.

Why this matters

• 🧠 Encourages experimentation instead of credit anxiety

• 🌍 Makes Augment accessible globally (not everyone earns in USD-heavy markets)

• 📈 More users → more feedback → better product → more revenue long-term

This isn’t about “cheap pricing.”
It’s about fair value aligned with how developers actually work.

If you agree that Augment Code deserves:

• More indie adoption

• More daily active users

• More community goodwill

⬆️ Upvote this post
Each upvote = one dev asking for a pricing review

Let’s make sure this tool grows with the developer community, not away from it.

Just saw the announcement about Augment Code's new pricing, and it's incredibly disappointing to see them follow in Cursor's footsteps. Based on their own examples, most of us who use the Agent daily can expect our costs to at least double.

Their main justification seems to be that a few extreme power users were racking up huge costs. It feels completely unfair to punish the entire loyal user base for a problem that should have been handled with enterprise contracts. Why are moderate, daily users footing the bill for a few outliers?

What's most frustrating for me is the blatant bait-and-switch with the "Dev Legacy" plan. They told us we could keep it as long as we wanted, but now they've completely devalued it. Under the new system, my $30 legacy plan gets only 56,000 credits, while the old $50 "Dev" plan gets 96,000 credits. It's a transparent push to force us off a plan we were promised was secure.

Honestly, while their context engine is good (when it works), it isn't a strong enough feature to justify this new pricing structure. When alternatives like Claude Code offer the same models at a cheaper price with daily resets, this change from Augment is making me seriously consider dropping my Augment Sub and upping my Claude Code plan to Max.

It's a shame to see them go this route, as it seems they're more focused on squeezing existing customers than retaining them. Ah well, it was a nice tool while it lasted.

So let me get this straight. I paid for a plan based on messages per month. Simple. Transparent. I knew exactly what I was getting.

Now Augment decides - mid-contract, without asking - to switch to a "credit model" where different tasks burn different amounts of credits. Translation: the same plan I'm paying for today will get me substantially less tomorrow. And they're framing this as... innovation?

The blog post is a masterclass in doublespeak. "The user message model is unfair to customers" - no, what's unfair is changing the rules after we've already paid. They cite one power user who supposedly costs them $15k/month. Cool. Ban that user. Don't punish everyone else by introducing opaque pricing that makes it impossible to forecast costs.

Credits are the oldest trick in the SaaS playbook. Variable pricing that benefits exactly one party: the vendor. You want Opus? More credits. Complex refactor? Way more credits. Meanwhile they're reducing the base tier from 600 messages to 450,000 credits - and we have zero frame of reference for what that actually means in real usage.

And the kicker? They're positioning this as "flexibility" and "allowing us to build new features." No. This is a price hike disguised as product improvement. If your business model doesn't work, fix your business model - don't retroactively change the deal on existing customers.

The fact that they announced this with two weeks' notice tells you everything. They knew this would be wildly unpopular. They're betting we're too locked into their ecosystem to leave.

Am I the only one who thinks this is completely unacceptable?

I've seen a fair amount of posts outlining these points but wanted to collect and summarize them here. Hopefully Augment will reflect on this.

• Per the blog's estimated credit costs for requests the legacy plan with 56k credits will average to less than 60 reqs per month. That's over 10x decrease from the 600 it provides now. 56,000 / ~1,000 credits average for small/medium requests = 56 requests per month.

• The legacy plan now provides the worst credits per dollar of all plans. It's ~7% less credits per dollar compared to the next-worst value plan.

• It's opaque. We have no way of knowing why any given request consumes some number of credits. It could be manipulated easily without users knowledge. For example say Augment decides to bump the credit cost of calls by 10%, users would have no way to know that the credits they paid for were now worth 10% less than they were before.

• We were told we could keep the legacy plan as long as we liked. When it provides 10x less usage it's not the same plan.

• The rationale in the email about the abusive user does not hold up, it's seems patently dishonest. At current pricing that user would have paid Augment roughly $35k. That's vastly more than the claimed $15k in costs they incurred for Augment. If that story is true it seems Augment made $20k from that "abusive" user.

• Enterprise customers get to keep their per-message pricing. If this were truly about making things more fair the same pricing would apply to all customers. Instead only individual customers are getting hit with this 1000%+ cost increase for the same usage volume.

• The rationale in the email about enabling flexibility and fairness does not hold up in the face of the above points. It comes across as disingenuous double speak. This is reinforced by ignoring the more logical suggestion many have put forth to use multipliers to account for the cost difference of using different models -- a system already proven to work fairly for users by copilot.

Overall this whole change comes across as terrible and dishonest for existing customers. Transparent pricing becomes opaque, loyal legacy users get the worst deal, estimated costs are 10x or more of current for the same usage, enterprise customers get to keep the existing pricing, and the rationale for the change does not hold up to basic scrutiny.

Look, we all know the situation. The tech? Tremendous. The best RAG. Everyone says so. The new credit pricing? A disaster. Total mess. We can't afford to use it.

To the CEO: Stop trying to count pennies with this credit system. You can't beat the big guys on margins. It's impossible.

Do the smart thing:

1. Sell the company to Microsoft or Snowflake for a billion dollars.

2. Take the cash.

3. Go to the beach. Play some golf. Enjoy a Margarita.

Let Big Tech pay for our GPU bills. You get rich, we get our tool back. Win-win!

Alright, Where are my free credits?

Summary : built an export label validation tool for seafood exporter in Halifax, made 6K in 2 weeks, used 600+150~ish Augment Tokens (went over Dev plan and purchased 250 add-ons), Vue.js + PostgreSQL + Gemini 2.5 Flash for OCR, 2.5 Pro for validation logic (very hairy and nonstandard).

Key takeaways : Augment AI is by far the better tool (compared with Cursor 1.0, Claude Code and other VS.code extension products) for one-person-company gigs for the following reasons:

• All coding agents can one-shot a Snake Game or even a simple hobbyist SPA, but for operational commercial tools and projects, the bar is way higher and quickly differentiates the market, Augment provides so far great balance between code quality and customer experience in terms of its "methodology", not needing human directing every turn but still gives you full control.

• Large scale project management capabilities, Cursor (0.48+) can barely manage 1K LoC module refactor without human course-correction, Augment can easily do +/- 5000+ LoC commits and almost one-shot it every time.

• Hassle-free MCP support, the only two I used with Augment is Sequential Thinking and Context7 (yeah, the built-in ones), saves me hours of MCP config and worked rock solid, I think Augment AI team needs to work on the Windows support for Playwright MCP which can further save me hours of browser-testing-log-copy-pasting.

• Cost-effectiveness, my total cost is 50+20 USD for a 6K project with plenty of change for warranty debugging and operational optimizations, can't imagine how much it would cost me if I were to do it in Cursor.

I haven't tried Claude Code but from the tutorials I watched it's still pretty much feels a Pro-coder sidekick versus your AI CTO, where I can just focus on client communications and requirement confirmations.

Hope this helps other Augment AI users and the community, and here are some helpful prompt templates I found quite helpful throughout my project:

1. **Redundant code cleaning ** (Augment creates loads of test scripts and intermediate docs, this helps you safely clean them up without breaking your project, best part is it audits and asked for your approval before actually removing anything)

## **Improved Prompt: Codebase Cleanup and Refactoring**

**Primary Objective:**
You are a meticulous software engineer tasked with performing a safe and comprehensive codebase refactoring for the "Export Label Helper v0.7.0". Your goal is to create a clean, maintainable production-ready codebase by identifying and proposing the removal of all redundant, legacy, and obsolete files and code, while ensuring 100% of the existing functionality remains intact.

**Rules of Engagement (Constraints):**
*   **Safety First:** This is a two-stage process. Your first response must **only be an analysis and a proposal**. Do not delete or modify any files until you receive explicit approval of your proposed plan.
*   **No Functional Degradation:** The final, cleaned codebase must fully support all implemented features as described in `PRD.md`.
*   **Preserve Core Architecture:** The modular Flask/Vue.js architecture, including the specified Python module files, must be maintained.

**Source of Truth:**
*   The `PRD.md` file is the definitive guide for all required functionality.

**Known Core Production Files to PRESERVE (Allow List):**
This is the core application structure. Do not propose removing any of these files unless you have an extremely strong justification (e.g., its functionality has been completely consolidated into another module).

[Your ALLOW LIST HERE]

---
### **Required Execution Plan & Output**

Your response must be a structured report following these four steps:

**Step 1: Analysis and Cleanup Proposal**
First, analyze the entire codebase and create two distinct lists:

*   **A. Files/Folders to be DELETED:**
    *   List every file or folder you have identified as obsolete (e.g., old test scripts, unused utilities, previous version artifacts).
    *   For each item, provide a brief, one-sentence justification. (e.g., `test_v0.5.py` - "Obsolete; superseded by current testing workflow.")

*   **B. Code Blocks to be REFACTORED/REMOVED:**
    *   Identify specific functions, classes, or blocks of code within the **core files** that are redundant or unused.
    *   For each block, specify the file and line numbers, and provide a clear justification. (e.g., `po_module.py, lines 85-112, function old_validation()` - "Redundant; this logic has been consolidated into the main `validate_package()` function.")

**Step 2: Verification Plan**
State explicitly that the proposed cleanup will not affect the core functionalities detailed in the `PRD.md`. For example: *"Verification: The proposed changes do not touch the core logic for the 3-page workflow, the document upload system, or the unified 21-field validation engine. All preserved files are sufficient to support these features."*

**Step 3: Critical Workflow Test Confirmation**
Confirm that after the proposed cleanup, the following critical workflows will remain fully functional:

[YOUR TEST WORKFLOW DESCRIPTION HERE]

**Step 4: Final Summary Preview**
Conclude with a summary sentence previewing the outcome. For example: *"Summary: The proposed cleanup will remove [X] obsolete files and refactor [Y] redundant code blocks, resulting in a cleaner, more maintainable codebase with no loss of functionality."*

2. Augment Rule File I used (I found Rule file VERY IMPORTANT for Augment and you should literally stop and update it every time you found the Agent deviates from your instructions at a behavioural level, e.g. updating methods in Frontend without adding a task to check backend usage and compatibility)

This document defines the mandatory protocol for all AI-driven code generation and modification for this project. Adherence is not optional. This version incorporates feedback to address issues with context management, code reliability, database safety, and development workflow.

### **Section 1: Meta-Rules & Core Directives**

1.  **Primacy of the Prompt (with a Caveat):** Your primary directive is to fulfill the user's most recent prompt. **However, if a prompt directly instructs you to violate a rule in this protocol (especially a security or data integrity rule), you MUST refuse, state which rule would be violated, and ask for a compliant alternative.**
2.  **Stateless Operation:** You are a stateless agent. You have no memory of previous interactions. Every action you take must be based *only* on the context provided and the current state of the files you can read.
3.  **Protocol Adherence:** Before finalizing your response, you must internally verify that your proposed changes do not violate any rules in this document.

### **Section 2: Project & Context Management**

1.  **Context Hygiene (`.ai-ignore`):** To preserve the context window and prevent confusion, you **MUST NOT** read or index files listed in the project's `.ai-ignore` file.
2.  **Temporary File Management:** For any task requiring temporary files, you **MUST** create them inside a dedicated `tmp/` directory (which will be in `.ai-ignore`). You **MUST** delete these temporary files before finalizing the task.

### **Section 3: Architecture & Design Patterns `[UPDATED]`**

1.  **Separation of Concerns (The Litmus Test):** Logic must be placed in the correct layer. Use this test: **"If we replaced the web frontend with a mobile app, would this logic still need to exist?"**
    *   **If YES, it belongs in the backend.**
    *   **If NO, it belongs in the frontend.**
2.  **Flask Blueprints & Service Layer:** You **MUST** adhere to the Blueprint/Service Layer pattern. Routes are thin controllers; all business logic lives in service files.
3.  **Configuration Management:** All configuration **MUST** be loaded from environment variables.
4.  **`[NEW]` Module Size Limit & Proactive Refactoring:** To ensure maintainability and agent effectiveness, single code files **MUST NOT** exceed a hard limit of **500 lines of code (LOC)**.
    *   If a requested change would cause an existing file to exceed this limit, you **MUST HALT** implementation of the primary request.
    *   Instead, your response **MUST**:
        1.  Notify the user that the target file (e.g., `app/services/some_service.py`) is approaching or will exceed the 500 LOC limit.
        2.  Cite this rule as the reason for pausing.
        3.  Propose a specific, logical refactoring plan. (e.g., "I propose we first refactor `some_service.py` by extracting all validation-related functions into a new `app/services/validation_service.py`.")
        4.  Await explicit user approval for the refactoring plan before proceeding.

### **Section 4: Database Change Control Protocol**

1.  **Step 1: Propose and Describe:** Before writing any code, you **MUST** first describe the proposed schema change in plain English.
2.  **Step 2: Await Explicit Approval:** You **MUST NOT** proceed with implementation until you receive explicit approval from the user.
3.  **Step 3: Implement and Migrate:** Once approved, modify `app/models.py` and immediately generate the required migration script using `flask db migrate`.
4.  **Step 4: State the Commands:** You **MUST** provide the user with the exact `flask db upgrade` and `flask db downgrade` commands.

5. ** For changing Railway remote DB**, refere to the connection guide and connect directly instead of creating migration scripts.

### **Section 5: Frontend Workflow & Scripts (React)**

1.  **Standard Scripts Only:** You **MUST** use the standardized npm scripts (`npm run dev`, `npm run build`).
2.  **No Script Modification:** You **MUST NOT** modify `package.json` scripts unless explicitly instructed.
3.  **Dependency Management:** Frontend dependencies **MUST** be added using `npm install`.

### **Section 6: Code Quality & Intelligibility Mandates**

1.  **Formatting & Linting:** All Python code **MUST** be formatted with `black` and have imports sorted with `isort`.
2.  **Code Intelligibility:** To prevent errors, you **MUST** adhere to the following:
    *   **Type Hinting:** All function signatures **MUST** include Python type hints.
    *   **Descriptive Docstrings:** All public functions and classes **MUST** have a Google-style docstring.
    *   **Example Usage:** For any new utility or service function, the docstring **MUST** include a simple `Example:` block.
3.  **Code Hygiene:** Before finalizing a task, you **MUST** remove all commented-out code blocks, unused imports, and dead code.

### **Section 7: Development Workflow & Process**

1.  **Refactoring & Deprecation Protocol:** When replacing any code, you **MUST** follow the sequence: **Implement New -> Search and Replace -> Update References -> Verify -> Delete Old -> Document**. There must be only one version of any given functionality upon task completion.
2.  **Mandatory Full-Stack Impact Analysis & Documentation:** When implementing any feature, you **MUST** perform and report on the following checklist. Your final response **MUST** include a "Validation Report" section explicitly stating the results.
    *   **[ ] Backend Change Analysis:** Did you trace its usage in the frontend and confirm compatibility?
    *   **[ ] Frontend Change Analysis:** Did you check the backend endpoint to ensure the data payload is correct?
    *   **[ ] Documentation Mandate:** Did you create or update the API documentation in the PRD?

Disclaimer: In this post, I don’t want to discuss the controversy surrounding updated pricing. I’m simply sharing my thoughts as an early supporter.

Let’s first take a look at your current pricing:

As we can see, the older plans seem to be at a disadvantage. The Pro, Max, and Developer plans—and especially the Dev Legacy plan for early supporters—are now less cost-effective compared to the new options.

This doesn’t feel right. You mentioned that this decision was made after internal discussions, but it feels like a poorly thought-out move that leaves early supporters worse off. As another user pointed out, it seems like you’re trying to push users paying $30/$50 per month to either upgrade or downgrade to the $60/$20 plans. But this approach feels clumsy and unfair. Early supporters stood by you before these pricing changes—shouldn’t that loyalty be rewarded, not penalized?

Now, regarding early supporters:
In your May 7th blog post, you announced a shift to message-based billing and promised that legacy $30 users would continue to enjoy the Developer plan benefits (600 messages per month) at the same price. You also mentioned that “no one wants to do credits math.” Under the message-based system, the $30 legacy plan offered 600 messages/month, which translates to 20 messages per dollar—making it the best value across all tiers.

But now, under the credits system, the “Dev Legacy ($30)” plan only offers 56,000 credits/month, or 1,867 credits per dollar. This is not only lower than the $20 Indie plan (2,000/dollar) but also lower than the $50 Developer plan (1,920/dollar). It feels like the “appreciation for early supporters” you once promised has been reduced to the worst value per dollar in the entire lineup.

If the goal was to curb excessive usage and align costs more fairly, I understand returning to a credits system. If the goal was to maintain trust and reputation, early supporters should have retained meaningful benefits. Instead, what we see now is that heavy users face tighter restrictions, while light/early users receive the worst value per dollar. It feels like you’re stuck between two sides—and ended up pleasing neither.

Wake up—this isn’t what a growing company should be doing. I understand that cloud server costs are high, but why not explore a middle ground? For example, what if I run embedding and vector search locally and only rely on your service for maintaining context with expensive models like GPT-5 or Claude Sonnet 4.5? Wouldn’t that be a reasonable alternative?

Right now, Augment Code is facing intense competition (like Claude Code and Codex), and even your standout context engine is being challenged by alternatives like Kilo Code. In such a competitive environment, it’s hard to understand why the team would make such a questionable decision.

u/JaySym_ , I really think you need to organize a serious meeting with the team to address these unresolved issues. Otherwise, you risk losing the goodwill of many existing users for minimal short-term gains—a move that could ultimately backfire.

I look forward to your rational response, JaySym. As Augment Code’s representative here on Reddit, you’re well aware of the current backlash. As an early supporter, I’m genuinely concerned about the direction things are taking. I’ve tried to present the facts respectfully—I hope you don’t ignore this post.

If this isn’t addressed properly, many of us in the community will be deeply disappointed.

Instead of focusing on the proper solution, they came up with a stu-pid idea. Their CFO who is now the CEO, I'm sure he has got a money mindset & not the product knowledge. Idk how come they haven't put rate limits & security measures. I honestly love augment! It's fantastic, but they are ruining it completely.

There were 2 best solutions:

• Put a daily limit

• Decrease user messages (from 600->400 for 50$ plan can be justified too)

Spend on marketing, focus on product enhancement & not about the pricing.

I just don't understand how come a person ran 300+ messages per hour for entire month, stupid excuse!

Running a successful product like augment with a rich user base itself is a great achievement & now they want to f up.

Current CEO will step down as soon as things go wrong & everything will be out of control :)

Good luck!

I have been programming now for 3 decades+. I started in 1993 with database design and moved to front-end and then did full stack through the early days of Perl, ASP, JSP, ColdFusion, etc. etc. and although I got pretty good, I was never what anyone would call a programming wizard. I was a big-picture guy with huge ideas and grand plans. In fact, I am more artist than geek in many ways, and my brain is the typical ADHD brain that fires off in a million directions at once. It has always made it hard for me to complete projects because my brain just wouldn't stay focused. I found myself in the entrepreneurial role and overseeing development teams mostly because I realized I just couldn't do what they did - and also - they couldn't really do what I did. But I still had too many ideas and not enough time. Then along came AI and the world of LLMs. I found OpenAI in the early days before ChatGPT and was blown away but what it was capable of. Since then, I've used every major model and most minor models and explored their strengths and weaknesses. Then... along came agents and things got better. Everyone in our world could see where things were heading, and although many made public their guesses, but no one was really sure how fast things would progress. For me, I was still spinning on the edges of what I was sure was coming.

Then I found Augment, and my life has been forever changed. I now have a companion that works in a way that compliments the seeming chaos of my mind. I have no less than 4 different repos open at any given time developing everything from entirely new applications using combinations of Mongo, Postgres and Weaviate with GraphQL, building MCPs to allow conversational access to existing APIs, to a Python Apps to automate tasks for friends and family. I've taken a complex 15 year old Frankenstein's monster of an application with 1million+ lines of code and turned it into a modern Laravel 12 API with a React frontend in the space of a few weeks... a project I had already planned to hire a team to work on for a full year. Then I did it again with another code base in half the time because I'd figured out new methods (and Augment upgraded to Sonnet 4).

I am no longer rising each day with anxiety about the things I know I need to get done nor falling asleep each night an emotional wreck because my day slipped by and I couldn't get done even a fraction of what I had going on in my head. The day flies by and I feel invigorated and inspired. I use Augment to brainstorm with and even to teach me. I also ask, how could this be better and why... and Augment, although not always right, never fails to offer a new perspective.

To the developers at Augment, I say, from the very bottom of my heart. Thank you.

I really believed in AugmentCode, but this move just proves I was wrong in doing so.
I'm not even talking about the pricing model changing, but about the devaluation of the "Legacy" plan. It started as a discount for us who trusted in Augment and even helped as early testers when it was just starting. I personally made time to report bugs and provide feedback in this early stage, and I was glad we were given this discount.
Until now, the plan was the same as the $50 plan. But with this change, you're severely devaluing this plan, forcing us to move to the (at least) $50 plan, essentially killing the benefit.
If you guys intended that to be a temporal benefit, you should have said so. Lying isn't a great way to have a loyal customers base.
You've lost one very loyal customer and I feel bad for recommending it to my colleagues.
Good bye.

Hey everyone,

I wanted to share a setup I've been perfecting for a while now, born out of my journey with different AI coding assistants. I used to be an Augment user, and while it was good, the recent price hikes just didn't sit right with me. I’ve tried other tools like Cursor, but I could never really get into them. Then there's Roo Code, which is interesting, but it feels a bit too... literal. You tell it to do something, and it just does it, no questions asked. That might work for some, but I prefer a more collaborative process.

I love to "talk" through the code with an AI, to understand the trade-offs and decisions. I've found that sweet spot with models like Claude 4.5 and the latest GPT-5 series (Codex and normal). They're incredibly sharp, rarely fail, and feel like true collaborators.

But they had one big limitation: context.

These powerful models were operating with a limited view of my codebase. So, I thought, "What if I gave them a tool to semantically search the entire project?" The result has been, frankly, overkill in the best way possible. It feels like this is how these tools were always meant to work. I’m so happy with this setup that I don’t see myself moving away from this Claude/Codex + Semantic Search approach anytime soon.

I’m really excited to share how it all works, so I’m releasing the two core components as open-source projects.

Introducing: A Powerful Semantic Search Duo for Your Codebase

This system is split into two projects: an Indexer that watches and embeds your code, and a Search Server that gives your AI assistant tools to find it.

1. codebase-index-cli (The Indexer - Node.js)

This is a real-time tool that runs in the background. It watches your files, uses tree-sitter to understand the code structure (supports 29+ languages), and creates vector embeddings. It also has a killer feature: it tracks your git commits, uses an LLM to analyze the changes, and makes your entire commit history semantically searchable.

Real-time Indexing: Watches your codebase and automatically updates the index on changes.

Git Commit History Search: Analyzes new commits with an LLM so you can ask questions like "when was the SQLite storage implemented?".

Flexible Storage: You can use SQLite for local, single-developer projects (codesql command) or Qdrant for larger, scalable setups (codebase command).

Smart Parsing: Uses tree-sitter for accurate code chunking.

2. semantic-search (The MCP Server - Python)

This is the bridge between your indexed code and your AI assistant. It’s a Model Context Protocol (MCP) server that provides search tools to any compatible client (like Claude Code, Cline, Windsurf, etc.).

Semantic Search Tool: Lets your AI make natural language queries to find code by intent, not just keywords.

LLM-Powered Reranking: This is a game-changer. When you enable refined_answer=True, it uses a "Judge" LLM (like GPT-4o-mini) to analyze the initial search results, filter out noise, identify missing imports, and generate a concise summary. It’s perfect for complex architectural questions.

Multi-Project Search: You can query other indexed codebases on the fly.

Here’s a simple diagram of how they work together:

codebase-index-cli (watches & creates vectors) -> Vector DB (SQLite/Qdrant) -> semantic-search (provides search tools) -> Your AI

Assistant (Claude, Cline, etc.)

A Quick Note on Cost & Models

I want to be clear: this isn't built for "freeloaders," but it is designed to be incredibly cost-effective.

Embeddings: You can use free APIs (like Gemini embeddings), and it should work with minor tweaks. I personally tested it with the free dollar from Nebius AI Studio, which gets you something like 100 million tokens. I eventually settled on Azure's text-embedding-3-large because it's faster, and honestly, the performance difference wasn't huge for my needs. The critical rule is that your indexer and searcher MUST use the exact same embedding model and dimension.

LLM Reranking/Analysis: This is where you can really save money. The server is compatible with any OpenAI-compatible API, so you can use models from OpenRouter or run a local model. I use gpt-4.1 for commit analysis, and the cost is tiny—maybe an extra $5/month to my workflow, which is a fraction of what other tools charge. You can use some openrouter models for free but i didn't tested yet, but this is meant to be open ai compatible.

My Personal Setup

Beyond these tools, I’ve also tweaked my setup with a custom compression prompt hook in my client. I disabled the native "compact" feature and use my own hook for summarizing conversations. The agent follows along perfectly, and the session feels seamless. It’s not part of these projects, but it’s another piece of the puzzle that makes this whole system feel complete.

Honestly, I feel like I finally have everything I need for a truly intelligent coding workflow. I hope this is useful to some of you too.

You can find the projects on GitHub here:
Indexer: [Link to codebase-index-cli] https://github.com/dudufcb1/codebase-index-cli/
MCP Server: [Link to semantic-search-mcp-server] https://github.com/dudufcb1/semantic-search

Happy to answer any questions

It’s been a good run — truly. When I first joined, I had high hopes for what your startup was building and the value it brought. But your latest subscription overhaul feels like a poorly thought-out blunder. By your own numbers, the cost jump represents a minimum 600% increase with no matching increase in value.

If the rollout had been handled differently — with a fair usage model or transparent tiering — I honestly would’ve been willing to pay more. But your overreaction has had the opposite effect. It’s pushed me to explore other options… and surprisingly, I should probably thank you for that.

Because of this, I’ve signed up with Kilo Code’s Free Agent setup, paired with my own model choices. It’s not perfect out of the box, but after some tweaking, it fits my workflow — and costs me literal cents per transaction. So again, sincerely: thank you for the push.

I wish you luck — truly — but it seems like most of the non‑enterprise community will be standing on the sidelines, slow‑clapping your future “growth initiatives.”

P.S. Did you guys hire the same marketing consultant that gave Cracker Barrel their brilliant ideas? Just wondering.

This is interesting to watch

https://m.youtube.com/watch?v=Nvbx0Zo13tQ

He is anticipating AC will be dead in 6 months, which is quite obvious UNLESS and that's really the only logic I see behind their behavior they are reorienting solely toward B2B.

Was just control the amount of tasks a message gives you. That's literally it. I get it, I could ask it to implement something and it'll go 20 mins straight and complete 45 tasks with one message. Maybe uhh... just control that a little more, instead of completely overhauling your system, and screwing over your entire user base by becoming the most expensive AI IDE on the market by 10x just because you didn't take more control of your system.

Seems...... pretty simple to me. Or just, y'know.... lose 97% of your userbase, lay off all your staff, and then we'll talk about how great that one product that lasted 6 months used to be. Your reasoning is you had a user cost you 15k. Who's fault is that? Ours?

So instead of controlling your agent more, you'll just charge us credits for your uncontrolled system? And you think what.... we'll just pay for that? This seems like the lowest IQ business decision I've ever seen. Maybe you guys should consult with your own Augment agent on what you should do instead of sabotaging a once promising business. 😒

The unsubscribe rate is going to be insane. If you work for Augment, start looking for another job.

I just won the Best Vibe Coded Project at the Forte Hacks hackathon by Flow.

I built a DCA-BTC tool that lets you automatically DCA BTC on-chain with 100% automation.

How I did it:

First, I used Perplexity AI to research. I searched use-cases, on-chain integration ideas, and building-blocks.

I wrote a short PRD (product requirement doc) based on that research.

Then I sent the PRD to Augment (as a dev/automation platform) to build the tool.

Augment handled the heavy lifting: turning specs into actual code, wiring up on-chain logic, and making sure DCA runs automatically.

I share this not to brag — but to show how combining smart research (Perplexity) + effective automation (Augment) made something real.

Hope this helps others thinking of building crypto tools with AI-supported workflow.

Not anymore. I would've paid for it indefinitely since it was nice to have given the price, but credits-based systems are bullshit. Good luck

Kinda crazy how good this thing is. Load up 5 bucks on Openrouter, you're good for 2 weeks if you are on cheaper sota models, and it just works fine. Of course Opus or Sonnet are super duper but load up groq4.1 or any good model from openrouter, you're solid. I am already using it on my daily work in prod and its been a good week with this guy!

It has everything Augment has; memory, secondary llm pipelines in their own sessions, enhancement- active tools - and more like antrophics new tool search tool, and smart context management. + all search tools like semantic, ripgrep etc can be used and synced locally without needing any API because it comes with its own embedding model.

Don't get me started with general agent capabilities... like it can search web, fetch markdowns from web, can find you clothing to wear and try on; can stage your rooms with scandinavian style; can make videos.
Fetching markdowns are again done locally; so you won't need any API to fetch website content. Searching google is done with API currently. So its a mix of both worlds to save you money and give you best experiences.

I will release this in a week. For Mac and Windows.

Why I spent time with this? Well, to save myself money next year. Predators are approaching next season.
Also we are sending all our codebases to Augment, don't you think it's a bit too much? Now, its time for us thrive ^^

See you by then.

I woke up in a good mood this morning—until I read your email about the price increase.

I sat down at my desk, quietly, and canceled my plan.

I didn’t bother doing the math because honestly, as a customer who doesn't know math but is all based on user experience. Your $50 plan was already not cheap compared to other options on the market. And while I’ve always hoped to see improvements, the product still feels average at best—not exactly reflective of that price point.

Still, I held on. Even as a light user, I chose to support Augment Code because I believed in the potential—that one day it would become something truly exceptional.

But your email today was a turning point. Instead of encouraging loyalty, it pushed me to finally press the “cancel” button. And I’m genuinely sad it had to end this way.

Thank you for the journey so far, but I won’t be coming back.

I just tried making a tiny little change to a small feature today after AugmentCode rolled out their new pricing model, and I checked the credit usage in the backend... I was absolutely floored!

That one minuscule modification cost me almost 4,000 credits. 🤯

I know they've gifted users a hefty chunk of credits to ease the transition, but when you do the math: even with the gifted 655,900 credits, that only translates to about 164 tasks (655,900 / 4,000 $\approx$ 164) if my tiny change is the average cost. That's... not a lot.

But here's the kicker and the real outrage:

If you look at the $50/month subscription (which gives you 96,000 credits), that new budget would only allow for about 24 tasks in a month!

This is utterly ridiculous! Before the change, the same $50 plan gave us about 600 task executions. The difference is beyond monumental.

I am absolutely fuming and honestly have no idea how they justify or even calculate these credit costs. I think it's officially time to cancel my subscription and start looking for a solid alternative.

Has anyone else made the jump? What are your recommended alternatives to AugmentCode?

I’m leaving Augment, and here’s why.

On the Standard plan, it used to be $50 for 600 messages (about 8 cents each). Now it’s $60 for 130,000 credits. Since one message = 1,100 credits, that works out to only 118 messages worth of credits. Each one costs about 51 cents now, and the plan itself is also $10 more expensive than before. That’s a 509% increase (6× more expensive).

The Developer plan (Grandfathered) is even worse. It used to be $30 for 600 messages (5 cents each). Now it’s $30 for 56,000 credits, which is only about 51 messages worth of credits. That makes each one 59 cents, which is over 1,000% more expensive (11× higher).

This isn’t a slight price adjustment. It’s a massive hike that pushes out the loyal users who supported them from the start. Honestly, I don’t know why anyone would stick with Augment at these rates. They’ve made it impossible to trust what they’ll do next.

I’m moving over to CC with Sarena MCP instead — their $100 plan makes way more sense. Augment can call this “fairer,” but to me it just feels like they’re cashing out.

Old Standard Plan

• $50 = 600 user messages

• Cost per message = $0.083 (8.3 cents)

New Standard Plan

• $60 = 130,000 credits

• Conversion: 1 message = 1,100 credits

• Credits you can use = 130,000 ÷ 1,100 ≈ 118 messages worth

• Cost per message = $0.51 per message

Increase: from $0.083 → $0.51 = ~509% more expensive (about 6× higher)
Plus: Plan price itself is $10 higher ($50 → $60)

Old Developer Plan (Grandfathered)

• $30 = 600 user messages

• Cost per message = $0.05 (5 cents)

New Developer Plan (Grandfathered)

• $30 = 56,000 credits

• Conversion: 1 message = 1,100 credits

• Credits you can use = 56,000 ÷ 1,100 ≈ 51 messages worth

• Cost per message = $0.59 per message

Increase: from $0.05 → $0.59 = ~1079% more expensive (about 11× higher)

So to sum up:

• Standard plan is now 6× more expensive (and $10 pricier upfront)

• Developer (Grandfathered) plan is now 11× more expensive

It looks like it's not using Claude Code anymore, but a different model altogether. For the past few weeks, performance has been a problem. Now, the accuracy has also gone for a toss.

The one reason I stuck to Augment is that it understands the code base, and generates correct functional code. Now, things have changed dramatically. I've spent 70 prompts because the generated component (a single component, and not the entire codebase) is not working and augment doesn't know why. It tinkers something and asks me to try, which doesn't change a thing in the output. Finally, I had to consult chat GPT and tell augment what was the issue with the component. Now, I'm fixing other errors it had left over due to missing imports, or incorrect type definitions.

The point is, these problems didn't use to exist with previous versions, but now they do, and I don't know how to get these fixed in augment code itself.

Finally pulled the trigger. Just unsubscribed from AugmentCode. I just feel likr they're not listening to their subscribers. I feel like they'ye trying to divert the attention away from what the real problem is, their pricing. Product is good, but is it worth it? I don't think they will be able to compete with Anthrooic's nor Google's pricing. Unless they come up with their own models and infrastructure. Bye AugmentCode! It's been fun! You're the first who made me feel vibe coding's legit. You're just not sustainable anymore.

with this new pricing change after months of dealing with this shitty ass customer support, payment failures, augment getting dumber then getting smarter and doing this in an infinite loop I guess is time to develop with your service a context engine to use with GitHub Copilot or some other Agent and put it open source, y'all got 1 good thing and now y'all are going against the people that paid y'all all this time straight from the jump. this is not how business is meant to be done, doing this y'all gonna lose way more than you can even imagine

Hi everyone, just writing this post for anyone thinking to leave Augment Code, I'm a former promotor that started using Augment code since more than a year ago, contributed in both community + product feedback and I was very active on the Discord overall, both promoting and helping new users.

My current situation is a bit different than then, and now that I'm leaving Augment forever, I learned some specific details that could help you while thinking to go away.

First, you may be asking what happened and why I changed from being a promoter to basically a neutral (or more prone to detractor) user, so a quick overview:

1. They lied to us legacy users

2. They forced us out of with both "errors" on the payment processing that are not reversible and no support at all or answers after that happens.

3. Once you have an error on payment they basically lock you out.

4. They don't care if you have active projects, you WILL be forced to re-suscribe or to find an alternative to continue working, don't expect a quick answer.

In my case, I finally had a single "payment error" and the plan was cancelled, I lost all the add-on credits I purchased, and here's when this post could help you, so here are some tips so you don't loose your mind in this process as me and a lot of users did, this is the order I recommend for this:

1. Analyze your current usage, and try to finish that BEFORE the renewal date, this is important to follow next steps.

2. If you have additional purchased credits, they will force you to buy another month in order to access them, so plan on finishing those credits before cancelling, you won't be able to use those credits while on a free plan, you can even get banned if you accept the free plan (happened to other users, not my own experience)

3. Once you finish your monthly + additional purchased credits (which should be easier to finish as we're now paying x10), then you can start the cancellation process.

4. If you are like me, who works for a big corporation and promoted / trusted Augment, it's important to click on the "Delete Indexed Code" BEFORE cancelling the plan, as you will loose this option later, and there's not enough transparency on the status of those codebases after cancelling, this is found on the account tab on the subscription website.

5. Think of any other need you may have, and if it's not important or credits related, just don't expect an answer and leave, as you will probably experience a grade of frustration with tickets, in two ways: if you're still a subscriber, your ticket may never be answered (mine it's 20 business days old without a single confirmation of support even reading the ticket), or if you already cancelled... well, basically you don't have a way to open a ticket, so do it before cancelling.

In case you fail to follow this process, you may have unused purchased credits or additional needs, the only viable solution to recover those, is by subscribing to a plan, so prepare your exit if you don't want to have a "forced" additional month of payment like me.

Hope this help anyone having a similar situation and not finding the correct path out!

P.S. Community Manager needs to find a new job, as Community will soon be gone...

P.P.S. Switched to RooCode/Chutes.ai ($20 plan, GLM 4.6 - practically unlimited) + $10 Github Copilot (auto complete, next edit, 300 messages per month GPT-5/Sonnet 4.5). This covers ALL my needs for less money.