You'll need nerves of steel to work with AI agents

Luna is unusable garbage. When I see people in threads talking about how useful Luna is for all of their tasks and it's so cheap and fast, it reads to me like people relating anecdotes about how tasty the garbage scraps they're eating out of the dumpster behind McD's are. Sol Max is the threshold of "just barely usable", and even then it's certainly not what the people are hyping it up to be.

> But GPT also offers a $100 plan with five times the usage limits. And how long would that last me?

Sol usage is basically unlimited on the $100 plan if you're human-in-the-loop, reviewing the code, and not doing some useless Gas Town crime against humanity.

Most of these issues are vastly improved or mitigated by adding clear instructions in AGENTS.md.

I follow a specific process with agents, and it works reasonably well: 1) describe my intended feature or change and then say “please recapitulate my intention and write an implementation plan” 2) read the plan carefully and refine it, make any corrections 3) tell the agent to go, but I check in frequently as it’s going. I watch the stream of thought and make course corrections or pull it out of rabbit holes 4) carefully review the result. Checking that tests actually fail, removing unnecessary changes 5) add instructions in AGENTS.md if I’ve found a new behavior that needs redirection

First of all, use Astra with Sol or Opus with Sonnet. Let the bigger model do the high level guiding. Claude Code even has an `--advisor` mode in the CLI. I mix with open weight models as well.

What you want is to branch questions in different agents and this is hard UX.

— Why is this function here?

This question can be but ideally should not be sent to an ongoing chat about a codebase. With some previous context, this question should become a separate "branch"/"fork"/"node" - whatever you call it. You can start a new session, share some context from previous chat and ask the question.

The reason is, and forgive me for assuming, if you are in a code/build flow, the LLM may go ahead and take action because it has a lot of previous chats with instructions to edit files.

In my experience the best way to not have these issues is to branch a new session with some context from which file you were looking at or your previous questions but as a read-only investigation.

> Inability to change the response style In recent months, I’ve been noticing a new pattern in sentence structure more and more often. Here are some examples: There’s a difference between "I read the text" and "I understood the meaning of the text". We too often mistake "I’m used to this" for "I like this". The path from "I’m afraid of making a mistake" to "I’m ready to try" can take years.

It’s worth taking the time to setup a style guide for your agent to remove llm-isms like this. Somewhat paradoxically, you can even have the agent help write it. Just include a couple of snippets of “bad” phrasing from previous chats, add some commentary about why it’s bad, and what to replace it with, and put that in your system prompt. I could provide examples but the whole point is that you can tailor it to exactly how you want it. This has the added bonus of being a quick sanity check for model quality. If you start noticing llm-ism appear, then likely the model is not following your instruction’s and the thread should be discarded/you need to switch to a better model

> For comparison, let’s take two $20 subscriptions, one for GPT and one for Cursor. With gpt-6.1-sol, my 5-hour limit runs out after just a few requests. If I ask it to change a couple of lines in a readme file, that uses up 10% of the limit. If I ask it to change something in a large codebase, the entire limit gets used up just reading dozens of files, without writing a single line of code.

Either this is hyperbole or something is wrong. I tried 6.1 Sol for a significant chunk of non-critical work this week and did not encounter usage depletion like this. I ran several tests that went upward of 450K tokens without depleting the 5-hour window, though I didn’t pay attention to how much.

Either this person is exaggerating, or something is extremely wrong with their harness.

I’m equally confused that their solution was to switch to Luna and try to use the small and fast model for big coding tasks. They could have switched to Claude $20/month and had ample Opus usage right new.

Most of the complaints in this article could have been avoided by not using Luna and not using a configuration that’s blowing their quota out for unclear reasons.

> With gpt-6.1-sol, my 5-hour limit runs out after just a few requests. If I ask it to change a couple of lines in a readme file, that uses up 10% of the limit

raises an eyebrow .. methinks he exaggerates. I don't think my €20 business plan gets more than the plus plan.

A minor README change with basic verification steps is cheap, or you have totally overdone your AGENTS.md / skills / other steering and have it running around in circles.

In general, if the AI needs to dig through a mammoth codebase to make a simple change, it's likely a codebase / design problem.

If you are making a cross-cutting change that needs that, then you plan up front, then divide & conquer.

Yeah I've never encountered any of that with Opus. It's pretty good at following instructions, and is also careful re anything sensitive or dangerous. Like just a couple days ago a Telegram bot I have it working on made a reply to a message in a chat that it shouldn't have, and I told it to fix the issue and delete the message (I don't have delete permission in the chat). It did the fix and stopped, saying it won't do anything that touches my service account; I had to tell if specifically again to "do the delete" before it did via the bot. Just one of many cases, and the reprompting can sometimes be annoying but I'm also pretty appreciative that there's way less of a chance it'll do something that has me tearing my hair out.

You're just using a model that's too weak for the tasks you're giving it.

You can go a long way with a weak model but you need to instruct it closely like it's a novice engineer. It's not super productive so it's better to have a smarter agent do the direction. The smarter agent will need context. You may be able to save on the context by building better indexes and docs of the code but you'll need to keep those up to date.

Or you could just use a smarter model, and perhaps a two-phase plan->execute modality. And maybe you need to get your payment card out. $200/month is still not a lot of money compared to salaries.

It's tradeoffs all the way.

Don't think you can build anything in a sentence, especially on top of a existing complex codebase. Typically I need to spend 30 minutes to get it spec right for a new feature, and then 30 minutes at the end to get it to review right (not reviewed by me but let it check things that might be missed). And I frequently bang my head against the keyboard: are you opus - these are intern mistakes

This is an excellent summary of the state of the frontier in March, 2026. It was frustrating. However. Things continue to improve, shockingly quickly, at the frontier. These are not major concerns I have with Opus 5.5 or Astra or Sol 6.1.

You’re using the wrong model for the problem. “Fast and cheap” agents like Luna are good for tightly scoped changes but won’t understand the “why”. Astra or Sol wouldn’t have that issue.

some people are not ready to read and accept this but I will say it anyway: stop reading code and trust that it does what you asked to do, focus on high level architecture and human description of what the system is doing. The only exception to this is if what you are doing carries a significant amount of risk that can't be mitigated with a follow up PR, for example launching a rocket or controlling an airplane.

Idk how you are running out of budget so fast. My usage is basically unrestricted tokenmaxxing ("/goal", flagship models at xhigh reasoning, etc) and my monthly burn is single digit thousands of dollars (maybe ~$350/day). Granted, my employer foots the bill so I don't care at all. But the return-per-spend is easily worthwhile and I'm not worried about the cost at these ratios.

Nerves of steel? Not even close.

I think 90% of the article is the author complaining about (predictably) bad small-model behavior. The large models are much better!

It just gets worse as your codebase grows with more code and more files especially. It's like a human developer who is under intense time pressure. If the codebase is large, it might miss an existing function and implement a second one... or it might miss the fact that a database table already exists to solve its current problem and create another one. The solution is to keep the codebase as simple and small as possible and name everything as intuitively as possible with proper separation of concerns. Same principles which were useful before AI are still useful with AI.

How people are getting anything done at all with less than 5-6 claude max and 4-5 codex pro max plans and codex-lb and better ccflare juggling weekly limits at all times, I will never know.

Some of the things you described about the bot reversing decisions after you question it and how it randomly deletes files based on your responses - it sounds rather unrealistic.

I haven’t experienced anything like that. My first inclination is to shout: skill issue. Because steering these language models is our responsibility. Reading 10 files doesn’t lead to 10% usage gone even on my $20 subscription. Try talking to your internet friends and find a better way to steer these agents.

Yea honestly I used to use claude sonnet all the time on pro plan and it had problems like this, but moved up to a max plan and opus makes it almost impossible to go back, higher usage limits aren't worth it if they force you to wrestle with ur agent all day instead of getting a ton built and running out of usage in an hour.

Sorry you had to suffer.

Bad models & bad harnesses are like blunt knives.

You are ironically more likely to hurt yourself if your knife is blunt - and less likely to get the job done. Once you do get the job done, it'll take longer and suck.

So,

Step 1: delete Cursor.

Life gets better from there.

You are right and here is my hot take into why working with models is a f pain. Harness... yes I have one https://github.com/alainnothere/privibe but is not what mine has that the other doesn't but what it doesn't have.

I suspect the whole reason for how bad models accessed through subscriptions tied to a harness of the provider (looking at you copilot) is that microsoft in the case of copilot "builds into the harness and hence into the model" an intention; and I don't have proofs (which qualifies me to start a popular podcast) but I suspect the harness keeps pushing the model to fix an issue as quickly as possible so the service can appear as "it just bam fixed the issue".

The "sitius altius and fortius" of the technobro is what you see in the tv ad "copilot check my git and fix a bug", how stupid do you think someone has to be to believe it works like that? my instructions to model say that I HATE urgency to make changes, we are researching and until we figure out causes, and understand all the mechanism involved AND THEN AND ONLY THEN we can check what's the actual intention, what business wants... then we can talk about a fix.

Grab a harness that injects the minimum possible and let the agent be and you will see how much difference there is in the quality of the model response.

"Why is this function here? *Discuss.*"

At this point I’d pay money for a good course on how to use AI for coding.

I’m not a Luddite, and the thing I most need at work now is a mid-seniority dev to support me. I don’t care if their name is Tanner, Prateek, Claude or Luna, I’ll take the help, except the meat-based variant is, IME, near impossible to hire (beats me - so many devs in the market, but the CV stack is deeply underwhelming, and the interviews only worse).

But every time I try to use AI agents - and frankly I only use the frontier ones as work pays for tokens - it’s basically what the author describes. Lots of random changes. The model happily saying it is doing X while also doing !X and also Y and Z, and sometimes gets stuck in some weird loop. Last time (admittedly not a frontier model but not far off) it wrote a Python script which would write another text file, with the contents defined as a concatenation of chr(XX) characters. That was enough.

Fixing or reviewing all this nonsense, or babysitting the model line by line takes more time than doing the damn thing myself.

What makes it worse is the cadence of babysitting an LLM is really awkward. Again, I don’t know what Im doing wrong. But reviewing things every 10 mins destroys my attention span. Even a junior dev is better in this regard - give them something to work on, describe what you need, review 1-3x / day for a week, and you hope to get somewhere. Even if it takes a long time, it’s not a major effort, so long as you’re ok with the latency. LLMs are the opposite - low latency, high noise. Lots of little efforts frequently, and all requiring full attention - because it’s easy to miss the little “rm -rf /” or other Easter egg Claude left.

So in short, it matches the behavior TFA describes. And yet lots of people see to be able to derive a lot of value out of it.

I have a lot of success writing medium length snippets with it, in a conversational style. Sort of up to 500-1000 LOC in things that aren’t challenging. Or building a scaffolding for a webpage. Or a non judgmental, zero lag replacement to SE/SO. But a mid senior dev ain’t that.

It’s not just a rant, any suggestions welcome.

Sounds exactly like the fever dream I see everybody live, lol

[flagged]

[flagged]

[flagged]

TL;DR: you get what you pay for.

[flagged]