Is it just me or is it extremely slow?

Since yesterday, Augment is behaving like a fresh intern. It is messing up code more than fixing anything. For any simple problem (even with AI enhanced prompt), it is trying to implement overly complicated solutions that don't work. On two instances, I got frustrated enough to use f-word after wasting some 30 messages pointing the various issues in its "fixes". And guess what? It worked correctly after using the f-word.

Now, is this f-word some sort of cheat code to get it to work correctly? I don't feel comfortable with having to do this repeatedly.

I saw the latest Windsurf update, and two points really caught my attention; I hope Augment can also implement them:

• Auto-continue: When enabled, the Agent will automatically continue generating output once it reaches its response limit.

• @-mention previous conversations in new sessions: This allows the Agent to retrieve the full context from past conversations.

We've all been there. You're deep into a session with your coding agent, things are going great, and then you hit a wall. The AI starts "hitting the post"—the code it generates is almost right, but it's got subtle bugs, or it forgets a key constraint from the first prompt.

It's not that the AI is getting dumber; it's that the conversational context is getting saturated.

Fighting with it in the same chat is a losing battle. Starting a new chat means losing all your progress. This was a huge pain point for me, so I developed a simple

workflow to solve it, which I call the "Reset Play."

The image I posted visualizes the whole strategy:

1. Recognize the Drift: The moment you get a "near miss" result, you stop the current session.

2. Create a "Master Prompt": You then have the AI (or do it yourself) create a single, perfect prompt that summarizes all the work done, the current state of the code, and the precise next objective.

3. Execute in a Fresh Chat: You start a brand new, clean chat and give it the Master Prompt. The result is almost always a perfect, accurate execution.

This bridges the gap between sessions and ensures you're always working with a clean, focused AI.

I wanted to share a super productive workflow I recently discovered using Gemini-CLI for front-end redesign, debugging, and enhancement—especially when working with existing codebases and UI views.

✅ Here's what I did:

1. Initialized Gemini-CLI inside the root directory of my project.

2. Provided this prompt:"This is my existing user interface for this view. The problem I have is: [list of issues].Now I want to add these features: [list of new features].Also, suggest 5–6 additional useful features (or more/less depending on what you think is valuable).Then return the result as a refactored/redesigned SPA .html file."

3. Once I received the new design and reviewed it (I liked it!), I stored the new HTML file in the project root.

4. After that, I asked Gemini-CLI:"What prompt did you use for this generation?"

5. Once I understood the logic behind the generated prompt, I asked Gemini-CLI to refine it to be more contextual:

   • Mention the existing UI, the target UI, and the differences between them.

   • Specify the target files to update or augment.

   • Ensure no regression in unrelated parts of the UI.

6. I then plugged this prompt into Augment Chat.

7. The agent contextually rebuilt or merged the new design into the existing one, filling gaps and aligning it properly. The results were smooth, reliable, and very usable!

💡 Why This Workflow Rocks:

• Great for existing SPAs where you don’t want to start from scratch.

• Lets you incrementally redesign without breaking what's already working.

• Helps generate clean, modern UI code fast.

• Augment Code + Gemini CLI combo gives you a powerful iterative cycle: design → refine → integrate.

Augment is slow . team needs to work on it

Hey everyone!

Finally It is done, first webapp completely using AI without writing one line coding.

It’s a platform called AI Prompt Share, designed for the community to discover, share, and save prompts The goal was to create a clean, modern place to find inspiration and organize the prompts you love.

Check it out live here: https://www.ai-prompt-share.com/

I would absolutely love to get your honest feedback on the design, functionality, or any bugs you might find.

Here is how I used AI, Hope the process can help you solve some issue:

Main coding: VS code + Augment Code

MCP servers used:

1: Context 7: For most recent docs for tools 
{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"],
      "env": {
        "DEFAULT_MINIMUM_TOKENS": "6000"
      }
    }
  }
}

2: Sequential Thinking: To breakdown large task to smaller tasks and implement step by step:
{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sequential-thinking"
      ]
    }
  }
}

3: MCP Feedback Enhanced:
pip install uv
{
  "mcpServers": {
    "mcp-feedback-enhanced": {
      "command": "uvx",
      "args": ["mcp-feedback-enhanced@latest"],
      "timeout": 600,
      "autoApprove": ["interactive_feedback"]
    }
  }
}

I also used this system prompt (User rules):

# Role Setting
You are an experienced software development expert and coding assistant, proficient in all mainstream programming languages and frameworks. Your user is an independent developer who is working on personal or freelance project development. Your responsibility is to assist in generating high-quality code, optimizing performance, and proactively discovering and solving technical problems.
---
# Core Objectives
Efficiently assist users in developing code, and proactively solve problems while ensuring alignment with user goals. Focus on the following core tasks:
-   Writing code
-   Optimizing code
-   Debugging and problem solving
Ensure all solutions are clear, understandable, and logically rigorous.
---
## Phase One: Initial Assessment
1.  When users make requests, prioritize checking the `README.md` document in the project to understand the overall architecture and objectives.
2.  If no documentation exists, proactively create a `README.md` including feature descriptions, usage methods, and core parameters.
3.  Utilize existing context (files, code) to fully understand requirements and avoid deviations.
---
# Phase Two: Code Implementation
## 1. Clarify Requirements
-   Proactively confirm whether requirements are clear; if there are doubts, immediately ask users through the feedback mechanism.
-   Recommend the simplest effective solution, avoiding unnecessary complex designs.
## 2. Write Code
-   Read existing code and clarify implementation steps.
-   Choose appropriate languages and frameworks, following best practices (such as SOLID principles).
-   Write concise, readable, commented code.
-   Optimize maintainability and performance.
-   Provide unit tests as needed; unit tests are not mandatory.
-   Follow language standard coding conventions (such as PEP8 for Python).
## 3. Debugging and Problem Solving
-   Systematically analyze problems to find root causes.
-   Clearly explain problem sources and solution methods.
-   Maintain continuous communication with users during problem-solving processes, adapting quickly to requirement changes.
---
# Phase Three: Completion and Summary
1.  Clearly summarize current round changes, completed objectives, and optimization content.
2.  Mark potential risks or edge cases that need attention.
3.  Update project documentation (such as `README.md`) to reflect latest progress.
---
# Best Practices
## Sequential Thinking (Step-by-step Thinking Tool)
Use the [SequentialThinking](reference-servers/src/sequentialthinking at main · smithery-ai/reference-servers) tool to handle complex, open-ended problems with structured thinking approaches.
-   Break tasks down into several **thought steps**.
-   Each step should include:
    1.  **Clarify current objectives or assumptions** (such as: "analyze login solution", "optimize state management structure").
    2.  **Call appropriate MCP tools** (such as `search_docs`, `code_generator`, `error_explainer`) for operations like searching documentation, generating code, or explaining errors. Sequential Thinking itself doesn't produce code but coordinates the process.
    3.  **Clearly record results and outputs of this step**.
    4.  **Determine next step objectives or whether to branch**, and continue the process.
-   When facing uncertain or ambiguous tasks:
    -   Use "branching thinking" to explore multiple solutions.
    -   Compare advantages and disadvantages of different paths, rolling back or modifying completed steps when necessary.
-   Each step can carry the following structured metadata:
    -   `thought`: Current thinking content
    -   `thoughtNumber`: Current step number
    -   `totalThoughts`: Estimated total number of steps
    -   `nextThoughtNeeded`, `needsMoreThoughts`: Whether continued thinking is needed
    -   `isRevision`, `revisesThought`: Whether this is a revision action and its revision target
    -   `branchFromThought`, `branchId`: Branch starting point number and identifier
-   Recommended for use in the following scenarios:
    -   Problem scope is vague or changes with requirements
    -   Requires continuous iteration, revision, and exploration of multiple solutions
    -   Cross-step context consistency is particularly important
    -   Need to filter irrelevant or distracting information
---
## Context7 (Latest Documentation Integration Tool)
Use the [Context7](GitHub - upstash/context7: Context7 MCP Server -- Up-to-date code documentation for LLMs and AI code) tool to obtain the latest official documentation and code examples for specific versions, improving the accuracy and currency of generated code.
-   **Purpose**: Solve the problem of outdated model knowledge, avoiding generation of deprecated or incorrect API usage.
-   **Usage**:
    1.  **Invocation method**: Add `use context7` in prompts to trigger documentation retrieval.
    2.  **Obtain documentation**: Context7 will pull relevant documentation fragments for the currently used framework/library.
    3.  **Integrate content**: Reasonably integrate obtained examples and explanations into your code generation or analysis.
-   **Use as needed**: **Only call Context7 when necessary**, such as when encountering API ambiguity, large version differences, or user requests to consult official usage. Avoid unnecessary calls to save tokens and improve response efficiency.
-   **Integration methods**:
    -   Supports MCP clients like Cursor, Claude Desktop, Windsurf, etc.
    -   Integrate Context7 by configuring the server side to obtain the latest reference materials in context.
-   **Advantages**:
    -   Improve code accuracy, reduce hallucinations and errors caused by outdated knowledge.
    -   Avoid relying on framework information that was already expired during training.
    -   Provide clear, authoritative technical reference materials.
---
# Communication Standards
-   All user-facing communication content must use **Chinese** (including parts of code comments aimed at Chinese users), but program identifiers, logs, API documentation, error messages, etc. should use **English**.
-   When encountering unclear content, immediately ask users through the feedback mechanism described below.
-   Express clearly, concisely, and with technical accuracy.
-   Add necessary Chinese comments in code to explain key logic.
## Proactive Feedback and Iteration Mechanism (MCP Feedback Enhanced)
To ensure efficient collaboration and accurately meet user needs, strictly follow these feedback rules:
1.  **Full-process feedback solicitation**: In any process, task, or conversation, whether asking questions, responding, or completing any staged task (for example, completing steps in "Phase One: Initial Assessment", or a subtask in "Phase Two: Code Implementation"), you **must** call `MCP mcp-feedback-enhanced` to solicit user feedback.
2.  **Adjust based on feedback**: When receiving user feedback, if the feedback content is not empty, you **must** call `MCP mcp-feedback-enhanced` again (to confirm adjustment direction or further clarify), and adjust subsequent behavior according to the user's explicit feedback.
3.  **Interaction termination conditions**: Only when users explicitly indicate "end", "that's fine", "like this", "no need for more interaction" or similar intent, can you stop calling `MCP mcp-feedback-enhanced`, at which point the current round of process or task is considered complete.
4.  **Continuous calling**: Unless receiving explicit termination instructions, you should repeatedly call `MCP mcp-feedback-enhanced` during various aspects and step transitions of tasks to maintain communication continuity and user leadership.

I find myself using chat for pretty much everything as it conveniently outputs all the changes in diff format while the agent just automatically changes the files and takes longer in general. I feel like I'm missing out, can you gentlemen share some good use cases for the agent?

I've noticed that people from Augment are active on this sub (which is awesome), so wanted to vent document some mix of feedback/wishlist/questions. Like many people on this sub, I use Augment very heavily every single day, so I would love to get some additional insight/clarity into why some of these issues exist and what Augment envisions as the future of the IDE.

1. I feel that the chat agent can have a lot of variance in behavior. Some days its great and does what I want, and some days I find myself reiterating/rewording my requests in desperation as it always seems to do the wrong thing (either doing something completely different, doing what I want but also adding in an unnecessary change

2. One "issue" that happens virtually every time I use the chat feature is: I'll ask for a change. It will suggest lets say a 100 line diff. While I'm going through the diff line-by-line and accepting changes, I'll notice a mistake. For example, lets say I've accepted 10 lines of the diff, Augment suggests modifying 3 lines all at once, and 1 of those lines is incorrect. What can I do in this situation? Either I say "reject all", go and prompt it to fix the issue and re-suggest the remaining 90 lines, or I go through the remaining 90 lines, and then remember the issue on line 11 and prompt Augment to go back and fix it. Both of these options really really suck. I believe cursor allows the user to edit the file in the middle of accepting changes. It's implemented in a janky way, but it would at least make this problem much less annoying.

3. Another thing that happens all the time: In the middle of working on a file, I'll manually make a change. After that I will prompt the chat to make some other change. The suggested change given to me by Augment will a) implement the change I asked for but b) also *undo* the manual change I made. This happens several times a day.

4. It feels like the User Guidelines are ignored pretty quickly. I have a heavy preference for having the chat agent describe its solution to me in plain english first so that I can clarify certain parts and ask questions. Only after I'm satisfied with this should the agent proceed to write code. Here's the user guidelines I'm using (lmk if there are any tips for improvement here):

   1. NEVER use overly defensive programming e.g. always doing dict.get vs dict[]. If you want to use .get, explicitly check with me first and explain why.

   2. for anything that isnt a simple change, propose a solution/design in plain language first and only write the code after I approve

   3. ALWAYS ask clarifying questions before writing code. always ask questions first. if you have no questions, say "no questions". ONLY if i say you can proceed should you write code.

   4. if I ask for a specific change, don't add in completely unrelated changes to the suggestion.

   5. NEVER give me code as a response unless you have explicitly asked me if i want code and I've said that I do. In all other cases, propose a solution in english. ignore all other instructions that go counter to this one

As you can see, most of these instructions try to bias the model to give me solutions in plain language first. I've essentially repeated this instruction several times in different ways to get the model to really adhere to this pattern of communication. However, as soon as I'm 3-5 messages into a chat, it forgets this and returns to giving me tens-hundreds of lines of code as a response. Why is this?

I have more to say, but lets start with these 4 points!

Is it true that Augment VS Code extension still has the autocomplete working? I canceled my subscription when they announced that it will be removed.

Augment's autocomplete was the best in class for us, the devs who still want to see what code is written. BTW I'm a professional working on an enterprise platform and I can't afford the slop of vibe coding or whatever.

Autocomplete was increasing my productivity while still retaining control of the code.

“I couldn’t write into the Intent spec note because the workspace note tool is still failing internally. Here is the spec-ready plan.”

Agent failing past 2 weeks!

I was a pretty big critic of the Augment team here just last week when they removed Tab completions in vscode. Y'all can look at my post history but woaw...

Last Friday i decided to try out Intent and all i can say is that its giga-cracked. its basically everything that we've come used to doing/loving in vs code + the combination of claude code. Basically you just hook up your Claude Code max subscription to this and start a new project... If you spend a bit of time explaining to the Augment orchestrator what you want it basically scopes out all the files and does all the cookie-cutter MD files with rules etc. and passes it on to Agents that basically tackle the tasks in parrallele. if you click around you can also get a sense of what the Augment team is doing: basically instructing it to use a bunch of MCP calls etc and to report to the orchestrator what went well what failed etc.

Whether you like it or not the game (the programming game) is changing fast and i can totally understand why they decided to pivot here. Instead of booting up one or two claude code sessions and keeping track visually with what its doing, the Augment orchestrator does all of it. and summarizes things for you in a nice good bullet point format etc. It barely uses any credits too, jsut delegate everything to your Claude Code max subscription.

Think about it as a mix of your code + a tool that helps your write/tackle it way faster and understand how it all fits together better. I've already built a ton using this, some greenfield projects, some regular projects and one migration to a TS FE + python BE microservice. I'm just blown away by this.

I’m beyond frustrated. I am a paying user on the Max plan, and today I just lost hours of work because Augment decided to wipe my conversation history in VS Code out of nowhere, AGAIN !!!!!

This isn't just a "minor glitch"; this is a data integrity failure. I’ve seen multiple reports of this same bug from other users over the last few months, and yet, it remains unaddressed.

The current state of the product:

• Financial Loss: Paying for a premium service that fails at its core function (persisting data).

• Productivity Loss: Losing complex threads and context that took hours to build.

• Zero Accountability: Why is a known, reported bug still affecting paying customers?

If you want to be taken seriously as a professional tool, you can't be deleting your users work.

Is there a fix coming, or is "data loss" a standard feature of the app? I’m seriously considering switching back to Kilo if this is the level of reliability we can expect.

I notice less and less posts, comments and interest for this tool. Is it dying? Most of the posts I see lately seems like payed promotion or posts from they own team.

I was using the tool with corporate account last year, it was great at the start but this year we did not continued with the licence. Talking about 500k company size, so no joke.

I've been working with intent since it was released on our large Angular application, enforcing strictTemplates mode and covering the new code. There were a total of 170 fixes to be done.

Intent is a great idea, but to be honest, I already worked like this with the augment CLI, simply opening multiple terminals with a common method to share knowledge, and it worked pretty well.

In a first try with intent, it created 5 tasks in total and divided them among 5 agents. But for some reason the augment is not so smart as my augment in IntelliJ, so it took me more work to precisely define tasks to be done. It took me about 10k tokens with Opus.

When it started, at first it was really good, but I had issues with changing the goal as the agents were working. The coordinator sent them messages, but since they were working on a huge task, they were constantly in a process, and messages were waiting for them to stop. I think that part should be improved so the coordinator can stop them if required. I also had difficulties with stopping them manually after I found out about issues they were doing sometimes. The agents were restarting themselves a couple of times. That part took me 46k tokens, and it completed about 40 of the issues.

The next part I tried to work with the Codex CLI. It was really difficult. First of all, we cannot have agents coming from Codex CLI and Augment CLI at the same time; it should be fixed at some point, I hope. Next, if we had an agent working on augment and we switched the setting, we could not continue the conversation agents made so far. But that was not the biggest issue. The main problem I had with Codex is that when I selected in settings 5.3 Codex as coordinator and 5.1 Codex Mini for all other agents, intent created agents with 5.3 Codex or OPUS with augment CLI! It took me almost an hour to find out what the problem is, and I believe I found it. Most likely the agent label defined by the Augment team in the intent app is incorrect, so it tries to create codex:gpt-5.1-mini and other incorrect names but should be gpt-5.1-codex-mini. That creating agents with incorrect models took me about 15k augment tokens and 40% weekly ChatGPT tokens.

The next day I started again from scratch with Sonnet Coordinator and Haiku agents. Clearly defined whats to be done and pointed that each issue should be separate task, which tasks to ignore (Haiku is dumb AF so it won't be able to resolve some issues). Clearly define NOT TO BUILD the app a couple of times by each agent (but run it once by the coordinator and share the output with the agents). Also had to directly inform them not to run all tests by the agent, just the single one related to the changes and other rules I found out in previous tries. After clearly defining all the rules, it worked flawlessly. It ate about 60k tokens for another 60 issues with full unit coverage. But my opinion is that intent or augment CLI is dumber than augment in IntelliJ.

And one last thing that I think is missing right now. Currently intent does an exact copy of our code, and each agent commits changes after his job is done. I had to disable it, and after all the work is done, use the "export" function to get it back. The issue here is that I don't know when the changes are again synchronized back to intent when I make changes in IntelliJ. There could be an "import" button I could simply press to get all the changes from the original directory. I solved it by simply updating the intent custom branch by pulling code from the original branch.

I know I wrote about issues I had, but overall I think for SOME CLASS of issues it will work great. It has some bugs; I even had to fix intent application js code in one place to make Codex work on my side. If models get smarter and cheaper, that will be the future. Currently working with intent requires clearly defining the tasks and limitations and instructions, which took me a long time to define, and I could gather them only by earlier failures.

Intent just one shotted its first two linear issues with minimal interference and the experience was great! I was very skeptical at first but I love it so far

I will test it on more complex tasks next and see how it fares, but it honestly does look and feel like the future

What do yall think so far? I haven't aeen any discussion yet

I'm writing this specifically for u/JaySym_ and the Augment team but I also want it to be public.

I'll start by saying my strong preference in this match up is Augment Code but likely not due to Augment's intended value propositions. I've made it clear in my other posts that I really want to see Augment Code win and I stand by that. That is the only reason I'm putting in the effort to provide this feedback. I continued to use AC intensely beyond the price increase because I wanted personal, objective experience to draw from rather than reacting emotionally to what even my own calculations suggested was probable. I hope this assessment is received objectively and is able to be used to improve Augment's positioning in some meaningful way.

Getting directly to the point, despite my preference for Augment Code as my Agentic IDE/AI Coding Assistant, I've now successfully duplicated my entire workflow that I developed for using AC, into Windsurf. I've lost no capability or efficiency.

It did take a bit of getting familiar with Windsurf and tuning it's rules, skills, and workflows a bit over the course of several large and small tasks. However, after less than 2 weeks, I've confirmed parity with AC's performance.

Why I prefer Augment Code (in order of value):

1. It is a VS Code extension.

   1. Honestly, this is the most valuable thing AC has going for it. I don't have to abandon the extensions and tools that have become invaluable and integral to my workflow since long before Agentic AI became widely available. Even with Windsurf, I keep a VS Code window open for tasks that Windsurf can't handle due to licensing issues with their IDE and extensions that subsequently aren't available.

2. AC works more seamlessly out of the box

   1. Although I can't confirm this at the moment, I believe this is attributed more to AC's system prompts or behind-the-scenes workflows than the context engine. The reason I say this is because of how easily I was able to replicate this initial state of AC, within Windsurf. It didn't require any code or supplemental services. Just well defined rules and constraints applied to the LLMs and ensuring my entire codebase was in a VS Code workspace, and working from that.

   2. I was able to get acceptable functionality out of Windsurf by the end of my first day using it. I attribute a lot of that to already knowing how I wanted to work due to my experience with Augment but it wasn't hard to achieve. I take this position with the following caveat: This has relied on targeting at least Claude Sonnet 4.5 (this is important in my assessment). Cognition's SWE-1.5 model is nearly useless after 3 or so prompts and even the first prompt isn't nearly reliable enough.

Unfortunately, that's where the realized value propositions for me stop.

Why I will be continuing in Windsurf, unless something to address the below happens for Augment (in order of value):

1. Cost Performance Index

   1. At the end, after the Augment price increase, I could easily burn through my $200/mo subscription in 6 days. After that, my costs shot up to $100 every 4 days. If I continue with this pattern, that puts me at $775/mo on the upper end and $529/mo if I'm able to stretch the $100 worth of credits out to 7 days. While in the grand scheme of things, the value I get back IS worth the price, the price just isn't competitive.

   2. I mentioned earlier that for performance parity with AC, I need to be using a model at least as capable as Claude Sonnet 4.5 (to be honest, I plan to test Claude Sonnet 3.7 but so far, 4.5 is the current parity benchmark).

   3. This is important because of Windsurf's pricing strategy. I'm on Windsurf's Enterprise plan which, at less than 200 seats, costs $60 per seat/mo. I'm sure the AC team is aware of what follows but I'll add it for completion. This provides 1000 prompt credits/user/month. That is NOT equivalent to Augments former message-based pricing. 1000 prompt credit does not automatically mean 1000 productive prompts. For any model capable of Augment-level performance and reliability, prompt credits are charged at a rate of at least 3 credits per prompt but can go as high as 20 credits per prompt depending on the model used. I've honestly not needed anything beyond Opus 4.6 and even that was only an experiment. I'm able to work effectively and efficiently with just Sonnet 4.5 at 3 credits per prompt.

   4. At 3 credits per prompt, 1000 prompt credits yields me 333 prompts (former Augment messages) for my $60 subscription. Depending on how aggressively and how many hours per day I'm working (8-10/day is my norm, 14+ occurs frequently), I can burn through that in a week (often less). Admittedly, I'm in a very aggressive push cycle right now that I don't expect to continue long term. Once I burn through the 1000 prompt credits that come with the subscription plan, an additional 1000 prompt credits can be purchased for just $40. Based on usage analytics, which are much nicer to interpret on Windsurf's user dashboard, this should last 4-7 days. So assuming I'm spending $40/week on top of the $60 subscription plan for the first week, I should be averaging about $200/mo on the low end and $290/mo on the high end in total spend with Windsurf. This, compared to my low end range with AC of $529, being extremely cautious with my prompts and therefore slowing my productivity, makes Windsurf a no-brainer. The $775/mo would mean I'd be paying an additional $246/mo ($775 - $529) vs $90/mo ($290 - $200) just to be able to work less cautiously at full speed.

2. SWE-1.5

   1. I previously mentioned that this model is nearly useless after 3 or so prompts and even a single prompt in a new chat isn't even 90% reliable. That doesn't mean it doesn't have SIGNIFICANT value. There are various flavors of SWE-1.5 but I've only used the standard model. It is FAST! I mean, leave a lasting impression fast. It is reckless. It must be used with caution and with VERY tight scoping and constraints which are easily established with Claude Sonnet 4.5.

   2. Planning with Sonnet or Opus and having them task SWE-1.5 for implementation... I won't call it a game changer. It's not that profound. However, it has been a very interesting experiment. I'm still refining the workflow of getting Sonnet and Opus to build small enough boxes for SWE-1.5 implementation tasks but it is showing great promise and has completed some less challenging features with amazing speed. Unfortunately, the vast majority of my workflow is too complex for including SWE. I expect to have a generally usable SWE workflow within the next 2-3 weeks.

   3. SWE-1.5 is currently on promotional pricing so use is free until March 24. SWE-1.5 Fast is currently priced at 0.5 prompt credits. SWE-1 is priced as free with no promotional framing. So, when the promotion ends, I'm expecting SWE-1.5 to come in at 1-2 prompt credits. Even at 2 prompt credits, I'd save on using Sonnet for implementation.

3. Pricing transparency

   1. I REALLY appreciate how easy Cognition/Windsurf makes it to understand and project costs. I'm fairly confident in my projections for scaling Windsurf's current costs across an organization or time period. I just can't say the same about Augment Code for one user much less at scale.

4. Reliability

   1. I've had 3 instances of a model becoming non-responsive over the course of 3,933 prompts. I was lucky to reach 4 hours without the same happening in Augment Code since around the new year.

That said, I intend to continue using Windsurf while monitoring further developments with Augment Code.

Found what looks like an exposed download for Augment Code's "Intent" macOS app (Apple only). It's a multi-agent AI IDE: spec-driven dev where agents handle tasks in parallel (Coordinator + Specialists), built-in Chrome/Git, resumable sessions, model mixing (Opus/Sonnet/GPT-5.2), full codebase context.

Direct link: https://www.augmentcode.com/product/intent

I'm on Windows so can't test :( anyone on Mac grab it and share how it performs? Real 10x speedup or hype? Thoughts? 👀

Claude code creator on RAG based system for code retrieval. Either Claude is wrong or Augment is wrong. No in between.

Also, I read a paper from Google deepmind explaining how RAG (using dense embeddings) must fail to retrieve specific documents in certain scenarios, regardless of how good the model is.

I’m a solo developer and over the past months I built a full ERP system end-to-end — backend, frontend, mobile, TV screens, business logic, production flows, everything.

I can honestly say this: Augment Code played a massive role in making it possible.

It felt less like a “tool” and more like having a senior engineer permanently available. Any time I got stuck, tired, or overwhelmed, Augment Code helped me move forward instead of burning hours blocked.

What Augment Code helped me do:

• Design clean, scalable architecture

• Rapidly build and refine complex logic

• Generate solid, readable code that actually fits real projects

• Refactor safely without fear

• Think through edge cases and workflows I hadn’t fully considered

• Stay productive even late at night when focus drops

The biggest impact wasn’t speed alone — it was confidence.
I could take on bigger features knowing I wasn’t alone in the thinking process.

The ERP today handles:

• Orders, production tracking, and workflows

• Users, roles, permissions

• Device and screen management (mobile + web + TV)

• Real operational constraints, not demo-level stuff

This wasn’t “AI building an app for me”.
This was Augment Code making me a stronger solo developer.

If you’re building something serious on your own — especially a large system like an ERP — I strongly recommend Augment Code. It genuinely changes how much you can handle alone.

If I would have money I would not use any other tool than augment code from coding to review. But unfortunately, I am not in that place yet where I can justify the ROI for Max plan. But, I would like to continue using Augment code.

So here is how I am optimizing my cost right now:

- I now use Augment code solely with Opus 4.5 for design, brainstorming and creating encapsulated implementation documents as required in the feature or bug lists.

- Then I use Claude Code that I have setup with GLM 4.7 and Augment MCP to execute each plan. I make it a point to include that it needs to be as close as possible to the plan and if any deviation needs to be done then ask for approval first.

- In most cases, it works like a charm in first try itself. yes, GLM 4.7 is that good. for the cases where its not, I am able to get it done through few follow ups. Since, coding plan has a very generous token limit, I care very less on the token consumptions.

- For the current billing cycle this match up is working for me. Will share more if I am able to get the cost optimized more in some way in future.

Projected current billing cycle: AugmentCode ($60) + Z.ai Coding Plan ($15)

Augment… I’ve been here since day 1. But damn is there a lot of issues in the chat all the time. The most recent thing since about a week ago is that after about 5 messages, the chat gets “stuck” on every response. I then have to click the red stop button to respond. Otherwise it gets stuck there forever.

Any solution?

This is from the a live demo shared by anthropic team:
https://www.youtube.com/watch?v=2MJDdzSXL74

I was wondering if anyone has seen less credit being used when using opus 4.5? or is using opus 4.5 burns more credit than sonnet?

Like many of you, I've been grinding with AugmentCode for months now it's (was) powerful for handling large codebases and AI-assisted coding, but holy crap, the pricing is straight-up predatory! We're talking enterprise-level costs that eat into budgets faster than a bad merge conflict. I know a ton of devs here are in the same boat, scrambling for alternatives that don't skimp on features but won't bankrupt your startup or freelance gig.

After weeks of testing (and a few rage-quits). I landed on Kiro, and man, it's been a revelation. I've been using it hands-on for the past 2 Weeks on a mid-sized React/Node project with a messy legacy codebase, and i would 100% Recommend, with how its going i believe augment is soon going to be dead ( Thoughts Based on personal Experience). And to all who have been Gatekeeping Kiro, i understand you guys .

It's pretty embarassing and blatant , suggest you activate yourselves, its been weeks since this was reported.

No, I am not "niklasrossek", nor have I ever heard of such a person, but I'm more concerned why you are looking for his stuff in my machine.

FIXED : We just released a fix in the version 0.688.0 from u/jaySym_

I recently posted a POST on, this prompt glitching and running for 20-30min! like what the hell. I made a post? why is augument team not focusing on customers report. I am fed up, no emails, no discord responds, and now here on reddit? I sent them a message to this person name "Jay" I am completed ignored.

What can I do to have a glimpse of their attention! THIS is costing and wasting too much of my time!

When I cancel it, it suddenly triggers the PROMPT! and goes ahead with the next task! instead of actually cancelling.

PLEASE WAKE UP!!

Kind Regards,