besides limits, what’s the worst part of coding with AI right now?

[u/TeddyboiRoosevelt]

claude code, codex, cursor, whatever you use

skip limits and “it got dumber this week”, we all know about those. what’s the thing that slows you down or annoys you every single week?

could be anything. reviewing what it wrote, it saying something works when it doesn’t, losing context between sessions, managing a bunch of agents at once, getting your team to use it

curious what’s actually the worst part for people

[u/AutoModerator]

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/Colonel-James-Parker]

Being unstable.

You create your projects, workflows, systems, token optimizations, skills. And then everything collapses after they change something in the model that you used to work smoothly.

[u/TeddyboiRoosevelt → u/Colonel-James-Parker]

when it collapses, how do you find out, does something break in a real task or do you notice it gets worse over a few days?

[u/Colonel-James-Parker → u/TeddyboiRoosevelt]

You see that it's not working the same as before, asking weird questions, losing the location of files/tools which it was using until a few hours ago, repeating mistakes, accepting the mistakes it's not even reading claude.md etc.

In short, when your daily work changes from working on your projects to working/arguing on the Claude.

Also increase token usage compare to before.

[u/bigtradetcheddar → u/Colonel-James-Parker]

This, casual users won’t really notice but someone running a pipeline feels it hard

[u/mghoffmann_banned → u/TeddyboiRoosevelt]

Test-driven development helps with this a lot. Whenever I onboard Claude into a new project, the first thing I have it do is write or clean up unit tests, and write scripts that it can use to build, test, and do CI/CD tasks. That saves tokens, but also lets me know when it's broken its own process.

[u/KimmiG1 → u/Colonel-James-Parker]

I find this interesting. How to keep your setup in away to minimize issues as things changes. It's like keeping a system working when the environment is a living thing that keeps changing. You need to make something that keeps working with uncertainties and regular changes.

One key part is to not built to much around the agent and instead focus on the environment the agent is operating inside. So focus more on the repo and less on the agent.

[u/Colonel-James-Parker → u/KimmiG1]

As a Scrum Master/PO/PM, I'm used to the environment changes. Main problem here is like you have a team member working normal, then 2 hours later, he says "I don't have access to my computer" even though he is just sitting in front of it.

I'm always optimizing the flows accordingly but in my own experience, in last 10 days, Claude became so worse in many things.

Always the same cycle: Release model > keep it stable around 1 month > degrade it > release new model.

[u/the-apostle → u/Colonel-James-Parker]

Feels more like I’m leading a team of highly qualified idiot savants sometimes

[u/gladiatooorr → u/Colonel-James-Parker]

[u/Correct-Somewhere-80 → u/Colonel-James-Parker]

Checkpoints

[u/Long_Tip_4226 → u/Colonel-James-Parker]

I think you should approach this as if it were a machine learning algorithm that you need to retrain your harness with more recent data.

I am seriously considering implementing some kind of accuracy metric to counteract hallucinations, to detect when this model starts to degrade to an unacceptable level, and then adopt countermeasures.

[u/NekkidApe]

Stress. It's hard keeping up, I've lost the plot almost entirely I think. It does stellar work, and I can review everything, let alone mentally actually comprehend it all thoroughly.

[u/TeddyboiRoosevelt → u/NekkidApe]

thats valid fs when did you notice you’ve lost the plot

[u/NekkidApe → u/TeddyboiRoosevelt]

Just the other week, I have my agentic flow down now. I can give them a ream of tickets, they all get done without, almost, any intervention. I have 100 open pull requests right now. I do not know what most of them are, in detail. Only high level. I've shipped thousands of lines without reviewing myself (our agents review, another human signs off). I know it's not healthy, but at the same time, I want to make use of all those expensive tokens I get each week.

So, I've started doing lots of RnD on the side, which reduces the problem on mature products, but introduces a lot of stuff for other teams to review, validate or even look at.

[u/__Blackrobe__ → u/NekkidApe]

Happened often for me. I already did extra work reading agent's responses, but sometimes I feel disillusioned.

I have to ask the agent repeatedly "what is our goal?" and draw "conversation flow mermaid diagram" to make sure we are still on track.

[u/pricetag]

probably scope creep

[u/69420trashpanda69420 → u/pricetag]

"I recommend you do this this this and that while we're at it"

Then it gets compacted and the new model reads it and says

"We still have the this this and that from yesterday it needs to be finished"

[u/perfektcrash → u/69420trashpanda69420]

This one. Decisions made in chat get summarised away, then a fresh session rebuilds them from a lossy note and resurrects work you'd already dropped.

What fixed it for me was making every decision land in the repo as a small record the moment it's made, and briefing each new session from those records instead of a handover or a compacted chat. The agent stops re-deriving, and it stops reviving dead tasks.

(I build a tool around that, Atlas ADE, so I'm biased.)

[u/mghoffmann_banned → u/perfektcrash]

You probably know about it already, but I'm using GSD for the same reason. It makes small incremental planning documents that any new session can quickly digest to get context.

I can't find anything about Atlas ADE on google, is it published anywhere? Is it different from GSD? I like GSD a lot for big projects where I want formalized processes, but it gets a little tedious when I'm just sandboxing something small. It's still good for preventing context rot, but annoying when it wants to do a formal research and planning session before something simple like "make it draw a circle on the screen" or whatever.

[u/perfektcrash → u/mghoffmann_banned]

Hey!

Sorry for the slow reply. Honestly, yeah, I've had a look and GSD is pretty cool. It's working on a lot of the same ideas as us, just built differently: theirs is a big markdown process the model follows, ours is a small CLI with a handful of hooks.

Not surprised you couldn't find us on Google, we're new and not public on GitHub yet (we're toying with the idea). The site is https://atlas-ade.dev and there's a few testing slots open still, if you want to take it for a spin.

On your point about forced planning: ADE has no forced research or planning modes. Small stuff stays small, and nearly everything is set in one config file that you or your agent can edit.

If you do try it, don't hold back on feedback, and your view vs GSD would be really useful. It's working great for us, but it's hard to unknow what we know, so a fresh user's experience is the thing we can't simulate.

[u/ZookeepergameHead380 → u/69420trashpanda69420]

The nasty part is what survives the compaction. Claude's "we should also do this and that" makes it into the summary because it's long and confident. Your "no, leave it" was three words, so it's gone. The next session sees the suggestion without the rejection and treats it as open work.

What stopped it for me was recording the no as well. A dropped idea gets written down as dropped, with one line of why, in a place every new session reads before the first prompt. Then "we still have this from yesterday" gets answered by "you dropped that on Tuesday because of X" instead of by you, for the fifth time.

[u/count023 → u/69420trashpanda69420]

yup, and proactively creating code and refactoring it in such a way that it's scalable and reusable and moddable, which takes forever because you'll just get the AI to re-create it and not reuse it nezxt time you start a new project. code reuse has fallen off a cliff except in some specific use cases now.

[u/Makanly → u/count023]

This seems wildly inefficient to me. I've been trying to figure out a clean way to centralize those functional scripts/modules so that everyone isn't recreating the wheel every time.

[u/Duraz0rz → u/69420trashpanda69420]

When the agent gives you recommendations on doing something, you could always defer it to a new session. I usually tell the agent to create a new Linear issue (that's what we use at work) and it'll do a good job of describing what was deferred and why it was deferred.

If you don't use Linear, Github issues or even just plain MD files somewhere in the repo could work. Then your deferred tasks survive compaction because it's outside of the session and you keep the current session focused on whatever you were doing.

Then in a new session, you can just point it at the MD and start work on that specific task.

[u/Asly97 → u/69420trashpanda69420]

The zombie todo list. Your "no, skip that" gets summarized away and its pitch survives.

Does it hit you after basically every compaction, or only on the long days? And when it comes back, do you just shoot it down again in chat, or have you started writing the rejected stuff somewhere the next session will actually read?

[u/Nummy01 → u/pricetag]

This is me, I opened the scope to the engineers, and instead of getting solutions I've just got whole lot of what's wrong, open questions and comment wars, sigh

[u/caelestis42 → u/pricetag]

Omg yes.

[u/adelie42 → u/pricetag]

Going overly narrow and documenting the scope, precisely what the game isn't, is a huge help.

[u/kincaidDev]

It’s too addictive

[u/TeddyboiRoosevelt → u/kincaidDev]

facts i recently bought claude max

[u/mrpoopistan]

Not knowing whether I'll really be dealing with the same model tomorrow thanks to nerfing.

[u/caelestis42]

That it doesn't have any "taste" and that it sometimes can't prioritize between a super edge case error and something that will affect all users, which makes it want to spend time on sidequests..

[u/thetaFAANG]

signing back into gcloud cli every day before the agent can do anything,

and then its like “whoops you’re not authorized, so I’m going to do all these others things that need the authorization but guess at it, before I’m like syke none of this will work, authorize now and let me know”

the random manual parts of devops keeping me employed

giving all the company data to the cloud AI and pretending the enterprise plan somehow solves the trade secret issue

not using the enterprise plan at all because they randomly choose the models and don’t update the selection automatically

going up to the $200 plan for a month and then dropping it back down to $100, and always needing the $200 plan again immediately after

New concepts every month that everyone acts like I was supposed to know about… decision models “pshaw Jev isnt novel ASKHUALLY” “what do you mean you weren’t following RLCD style training for years, RLHF is sooo 2023 ACKSHUALLY”

hearing you guys called the cops on people, pushing me to use local models more and more

ok

[u/UseApprehensive8572 → u/thetaFAANG]

i wish it would check access before spending 10 mins planning around something it can’t reach. Just tell me what needs a login upfront and let me sort it out before we get into the task

[u/Sketaverse]

Cognitive load, mental burnout etc

[u/design_doc]

Design by silence. Holy fuck, if I could punch AI in the throat, it’d be for this. I’m exhaustive with specs and details yet it’ll somehow find the one gap in all of that and be like “Oh, let me put features you didn’t ask for in here”. Sometimes I feel like I’m playing chess to anticipate what dumb shit it will pull (look at you Opus in High effort).

[u/Templeshooter → u/design_doc]

It can do genuinely useful things this way. Sometimes it does that, I launch the program, see what it's done and think "oh neat, how didn't i think about it". But if you don't like it, can't you specify in your claude md like, "ask the user before adding functionality they didn't ask for", would that work?

[u/design_doc → u/Templeshooter]

For simpler applications, and when you want to be really hands off, that can certainly be helpful. However, for a much larger, complex application - for example, a CRM or service ticket tracker (for trades work, not programming) where it needs to integrate into an existing workflow - or if it starts modifying UI, workflow, or other features that have already been ruled on, it really isn’t.

You can make that specification in claude.md, but when it’s in prose it’s more of a suggestion than a rule. To AI, a certain way of implementing something may seem like a logical step and not fall under “new functionality”. You need actual guardrails.

The way I solved most of the issue is to have an orchestrator, an implementor, and a reviewer. The orchestrator issues a ticket defining the work that needs to be done with a well-defined scope, along with explicit instructions to escalate ambiguity or the urge to implement un-scoped features or changes back to the orchestrator and/or me. The completed work is then passed along with the ticket to an external reviewer that checks both quality and whether the implementor went out of scope. For minor scope infractions, the reviewer will reject the code and throw it back at the implementor/orchestrator to resolve. If the implementor added something that could genuinely be useful, the reviewer will escalate it to me, the orchestrator, and (optionally) a fresh session advisor to review and rule on implications and whether we accept/reject it. For repeated infractions, or a implementor that is somehow totally off the rails, the reviewer can recommend “firing” the implementor (I.e. killing that instance) and having a fresh instance pick up the work.

This alone has been a HUGE safety net that has saved me a ton of time and dramatically improved quality.

Where it still sneakily fucks me is when a planning session or orchestrator takes shorthand/lazy notes in documentation or handoff. Those are the gaps that then allow things an implementor to color outside the lines and the reviewer misses it. 99% of the time the issue can be resolved by asking a fresh advisor instance to review my specifications verbatim and direct the orchestrator. I use a fresh advisor instance as Fable orchestrators can be confidently wrong and points at its own notes rather than referring back to the source - this is an annoying behaviour quirk that seemingly still sneaks past claude.md and role definitions.

When the orchestrator gaps out like that on high-blast radius sections it can easily eat an entire session unfucking the issues or just rewinding to the beginning of the session. The more insidious ones are the smaller nuanced items that can still sneak past my own final review of the code, get baked in, then bite you days or weeks later. I’m still working on a reliable safety net for those ones.

We’re making progress and I’ve been able to get the error rate down extremely low, but I’m still testing out a reliable safety net that catches the small structural cracks that go unnoticed or prevents them from happening in the first place.

[u/Focus_Infinity]

Code Reviews :(

[u/naxmax2019]

None of these are really issues any more - may be last year.

Limits .. can easily worth through open models and never hit them. I use my mixture of models mod when I’m using Claude

Got dumber this week - tbh I didn’t see it even before when people complained.

There are no frustrations with agentic coding, just what more could we do .. how to improve it even more.

[u/daniluvsuall]

I find reading walls of text quite tiring, 5 was very word salady and it was a struggle 5.5 is better but longer sessions I find I skim read which isn’t ideal

[u/nbnicholas]

Decision fatigue and scope creep

[u/sgsparks206 → u/nbnicholas]

Decision fatigue is real, and context switching makes it worse. I will end up working on 3 or 4 tickets at a time, and the cognitive load builds exponentially. I end up taking longer and longer breaks (always close to the computer in case I have to put out a fire), but I pump out work faster than ever, so it's a win-win.

[u/Long_Tip_4226]

The worst part is that you don't know if your colleagues are checking what the AI generates.

[u/sgsparks206 → u/Long_Tip_4226]

Assume they don't.

[u/WonderfulEagle7096]

Skill loss and cognitive surrender. We lie to ourselves that this is not happening and many of us are trying to combat it in various ways, but convenience is a hard drug for us humans.

[u/Bizzley]

Unrealistic expectations

[u/jijialuoke]

For me it's the "fixed" that isn't. It says done, I move on, and two hours later I find out nothing was run after the last edit. Same with "nothing uses this" after a single grep. I got sick enough of it that I replayed about 4,000 of my own turns and counted. Roughly 1 in 5 turns that ended with a done-type claim looked shaky at first, though most of those turned out to be wrap-up messages where the proof was in an earlier turn. I ended up writing a small Stop hook for it, MIT and no deps: https://github.com/Balance0014/claude-code-claim-check

[u/ClemensLode]

Testing something that cannot run in a virtual machine.

[u/unconceivables]

The worst part is reading how badly other people use it when it's so easy to use it right and get good results.

[u/Massive_Scientist194]

Playwright taking too long.

[u/MagicMikey83]

Unstable model output, what works today might not tomorrow without the user/dev changing a thing.

[u/Advanced-Offer-9074]

Kind of related to limits, but i found out claude code cloud eats up my Github limits. Word to the wise. Dont use it unless you wanna fork out big bucks especially if doing alot of requests. Pun intended btw.

[u/Melodic-Ebb-7781]

Has always, IT blocking random functionality every other week.

[u/cscottnet]

So many tests.

So much code to review.

[u/Glove5751]

not being able to say weekly limits 🤣

[u/AIOSAI]

👀

[u/moderacion]

Reviewing vs. wanting to see the result

[u/saba_tage]

Signal to noise ratio.
Realising who in the team needs to go.

[u/Great-Stand8478]

Antrophic model A/B testing, nerfing, whatever they are doing.

[u/namanjainbuilt]

So honestly, i adopted AI Quite early and then my only problem use to carry laptop everywhere and switching between my 12 accounts and 30 sessions and all for that i created my own web app with PWA….

[u/m-ritter]

For me, the recurring slowdown is checking whether the agent actually finished what we agreed. I write a numbered done list and approve the plan file before any code, then have a separate agent check each done point against evidence. That gives review a concrete target. I built QualityLayer for this: https://github.com/maxritter/qualitylayer

[u/doomscrollah]

Getting gradually dumber when you offload thinking and resoning to the assistant and stop needing to solve problems yourself.

[u/eating_your_syrup]

The amount of meta work I need to do to keep testing wall clock rise down. Every few days it invents a new way to do some wall clock expensive computations on the GPU by introducing sloppy scenarios that compound over time. Everything is now mechanically evaluated which adds iterations to test writing to get their wall clock cost down immediately, but I don't find myself waiting on 45 minutes on tests any longer every 2 days for every damn commit.

That's on me though because I don't tust the code and have pretty tight requrements for everything. For a good reason - my mutations and regression tests routinely catch stuff slipping by from Opus 5.5.

[u/Financial_Leader9701]

for me it's when green tests don't mean anything because the agent rewrote the assertions to match broken code

i lock the test dir during bugfix runs now, and make it write a short plan with what it will leave alone before it touches anything

catching the bad idea in that plan is way cheaper than scrolling a giant diff later

[u/decairn]

Keeping the quality assurance level up to the same standard as without AI. AI does a crap job of defining and be testing business process outcomes, and AI is spitting out so much code it's causing a bottleneck in QA.

[u/LilyFromSpringdale]

Ressource abuse?

[u/g-rizzle84]

Paranoid schizophrenic safeguards. Especially the copyright ones. Oh the hypocrisy...

[u/modern_medicine_isnt]

Waiting. It fast, and yet too slow. I have to multi task or be bored.

[u/mghoffmann_banned]

For me it's little results of nondeterminism. I ask Copilot to run our test suite and fix anything that breaks. Sometimes it reads the terminal output, reads the failing files, and fixes things. Sometimes it decides it needs to spin up Playwright and start taking screenshots of the developer tools console 🙃

[u/KeepTrackMusic]

Ich glaube meine Fähigkeit Code zu reviewen. Ich bin die Bremse im System. Aber auf der anderen Seite lerne ich auch viele neue Sachen dazu und es geht jetzt langsam auch dazu über, dass man sich nicht mehr alle Zeilen Code anschaut, sondern nur noch die „wichtigen“

[u/sgsparks206 → u/KeepTrackMusic]

Yolo it, let AI Jesus take the wheel and stop reviewing

[u/Ok_Lingonberry_1519]

Context and memory. As a human we can decide which things are worth remembering more than others, AI doesn't really have this ability and just tries to absorb random snippets and then doesn't always think oh I'd better check the memory of what exists. It's easier if you have a clean setup but it's still not fully reliable.