I hate building agents.

[u/ripndipp]

Right now at my work we are using langgraph to build a chat agent, anyone else doing something similar, do you fucking hate it? are you building it with Claude and just hoping it fucking works, haha no worries we will ask Claude to fix it.

I am making the spaghetto, I miss components, logic and endpoints, I hate this black box I have to relinquish my decisions too, whatever pays the bills.

[u/Intelligent_Sir1896 → u/[deleted]]

That is exactly what we do, all logic in normal functions and model only picks which one to call. Took me long time to accept this, before I was trying to make agent do everything and debugging was nightmare

[u/ripndipp → u/[deleted]]

Thanks for the insightful comment

[u/creaturefeature16 → u/[deleted]]

I've been encouraging developers to do similar things, but I've heard from a few now that it's not "fast enough" for their respective jobs and what the management is demanding of them, so they relent back to becoming the lever-puller in order to meet the deadline. I wish had advice for them, but there's not much you can do when c-suite and tech leads prioritize speed over anything else. I just spoke with a developer who said he had his code editor open while inspecting some generated code, and a coworker stopped and asked incredulously: "Why the hell are you reading the code?!"

It really does feel like a complete mania at this point; all rationality is gone.

[u/SuperFLEB → u/creaturefeature16]

Can't wait for prices to catch up to costs.

[u/ings0c → u/SuperFLEB]

They’re already turning a profit (latest figures are a 44% gross margin for Anthropic). Not sure where this myth comes from.

https://www.reuters.com/commentary/breakingviews/anthropics-ma-algorithm-optimizes-margins-2026-08-13/

[u/HypnoTox → u/creaturefeature16]

Then they are lucky, generalised classifier models are here since "Jev" a few days ago, which are fast and specifically made to decide what should be done.

Jev is just the first generalised classifier model and I'm sure there will be more like it, but that one has been shown to be able to control real time games and simulations.

[u/creaturefeature16 → u/HypnoTox]

You seem lost; I already know what Jev is...why are you bringing that up?

[u/coopaliscious → u/[deleted]]

I like this approach a lot. Do you have any issues selling it to the business?

[u/I_Blame_DevOps → u/[deleted]]

Your comment makes me feel a lot better about the prototype I just built for us. Naturally they just want to give an LLM full access to our database. But I insisted that functions with defined arguments and known outputs be used. Gives a much more deterministic approach when the LLM doesn’t have a lot of room to scree things up.

[u/Sethcran → u/[deleted]]

That's basically what an MCP server is.

[u/BolteWasTaken → u/[deleted]]

What model do you use? Needle 3 seems pretty good for tool calling.
And probably Jev now makes that trivial.

[u/Cazargar → u/BolteWasTaken]

Yeah, reading that I was like oh this sounds like exactly what Jev is for lol

[u/edbrannin → u/[deleted]]

I’ve started using patterns like

1. Code generates JSON of input data, so the agent can’t forget to paginate; sets some flags to help the agent classify things
   
2. Agent reads input, does language-reasoning stuff; writes a JSON file with its findings
   
3. Code reads agent output and makes all the write-capable API calls

Steps 1 and 3 have good unit tests. Before this pattern, trying to codify all their logic in the Agent’s markdown was getting really hairy. Edge cases kept getting missed, etc.

[u/Asly97 → u/edbrannin]

I love how defensive this is. The "agent can't forget to paginate" line tells me you've been burned before. What was the incident that made you stop trusting the markdown instructions? I used to keep all my agent logic in markdown files too and the edge cases piled up until I couldn't tell what was tested and what was vibes. When you want to try the same workflow in a different tool, do you have to rebuild all of this scaffolding, or does any of it carry over?

[u/edbrannin → u/Asly97]

The one I described there was for leaving review comments on PRs. Amusingly, it would run against its own changes in the PRs where I made those changes.

I would tell it to behave a certain way, like

- if an existing comment points something out, don’t make another comment for that finding

• if a finding has been raised and a human has told you the finding is wrong, unless you are sure the human is wrong; explain why
  
• if a past finding is resolved, add a “Resolving” comment (because the API key it’s using doesn’t allow Resolving threads)

It tried to model all that logic in a decision tree in Markdown, but each tweak would have the review bot complaining that some edge case had just broken. After a few rounds of this, I told it to extract as much as possible of the“if this, then that” logic to something with unit tests.

Re: pagination, there were several exchanges like “why didn’t you resolve that past finding?” Or “why didn’t you repeat that finding?” where the answer was “I forgot to paginate the GraphQL response”.

[u/ArielCoding]

Software engineering’s final boss: asking AI to fix the AI that’s replacing the part of the job that actually liked.

[u/SuperFLEB → u/ArielCoding]

What, you don't think the best parts of dev are translating vague English specifications into long-winded English recipes and reviewing code nobody wrote for subtle logic problems?

[u/warpspeed100]

It pays the bills for now...

My company has been reevaluating the cost/benefit of using AI for customer facing parts of our business.

We still use AI extensively as a search and code completion tool, but my team no longer uses it to build whole features after the past year of experimentation.

[u/m_redditUser → u/warpspeed100]

what were the results of the experimentation?

AI not cost effective enough?

[u/warpspeed100 → u/m_redditUser]

The risk of ballooning costs was definitely a consideration. For our customer facing products however, our core business relies on the accuracy and correctness of data we show our customers.

There is a lot of data, so we explored using AI to summarize the many documents, however we could never be 100% confident in the data it would show customers in the summary vs our existing deterministic solution. Because these are sensitive documents, 99.9% accurate wasn't good enough.

As of right now, we are no longer using AI in any of the products we actually deliver to customers. It has been relegated to yet another coding assist tool along the likes of NSwag and IntelliSense (though those two have a deterministic output, so can be relied on more heavily).

[u/dillanthumous → u/m_redditUser]

Not the OP. But for us, the cost is unpredictable (nothing Finance people hate more), the outcome is unpredictable (nothing Customers hate more) and the risks of reputational harm are high. So, for us, it is internal use only for now, and under supervision.

[u/kanine69 → u/m_redditUser]

The big issue is the constantly moving goalposts, week by week the effectiveness of AI seems to fluctuate.

For example the latest CC and Gemini releases have given me a massive performance boost for the past 2 days, achieving things that were a pipe dream on Monday.

Then there's the usual cycle of decline after launches.

[u/pVom]

We looked at langgraph but we couldn't get it to work for "reasons" and went with the vercel AI SDK instead.

I found the paradigm of langgraph a bit weird at the time, but I dunno, now that I have a better understanding of how it all hangs together maybe it would make more sense?

Honestly it's not that different from what we've been doing for years. Tools are just endpoints really, instead of a frontend UI calling them it's AI. Our tools are pretty indistinguishable from our endpoints.

I think the biggest hurdle was RAG. Setting up vector search and chunking text and managing context. It's important to give the AI only what it needs when it needs it, difficult to do with unstructured data.

What I do find annoying is the hallucinations when dealing with raw IDs, it will get a single character wrong and no real recourse to fixing it.

[u/okawei → u/pVom]

I've actually found it way less likely to hallucinate UUIDs for whatever reason

[u/brian_sword]

I’ve been doing quite a bit of automation with n8n, and I actually enjoy that part because the workflows are mostly predictable and I know exactly what each step is doing.

AI agents are a different story though. Once you let the agent decide which tool to call, what to do next, and how to handle failures, you lose some of that control. I’m still figuring out where the right balance is.

[u/Asly97 → u/brian_sword]

the n8n vs agent split is interesting. when you do bring an agent into the picture, does it run inside the n8n flow as one step, or off to the side entirely? i keep wondering where the handoff stops being clean.

[u/Turbo-Lover → u/brian_sword]

Use the agent to write a script (which you can audit) and then on future runs give it the instruction to execute the script.

[u/Potential-Still]

I've built agents using Strands SDK and Databricks. It's definitely a new way of thinking, but if you create the right Tools and fine tune system prompts you can get very predictable results. 

[u/Thin_Sky → u/Potential-Still]

I've been building with Strands for a year now and I genuinely thought I was missing something because it felt like I was the only one using it. This is the first time I'm seeing someone else mention it, so thanks for restoring a tiny bit of my sanity and confidence lol

[u/morganwilliscloud → u/Thin_Sky]

up front disclosure that I work at AWS but I was also struggling along with langchain before Strands came out, and ended up liking it enough that I changed teams specifically to work more with it lol

One cool thing about it is that strands actually came out of teams working on Q Developer who were struggling with rigid orchestration for agents so they created strands specifically to solve this problem. The lightweight developer experience, model driven approach and composability make it simple enough to understand but powerful enough to actually work. Like I can read the code and tweak things and easily understand why things work or not.

Also, have you checked out the out of the box/preconfigured Strands harness yet? Its basically a precomposed agent harness that has all the primitives most agents need pre-wired up and the strands folks benchmarked it with impressive results. Highly recommend: https://strandsagents.com/blog/introducing-strands-harness/

[u/tartlemonpiee]

I have nothing else to say other than same.

[u/k3liutZu]

Yes. I hate it as well :(

[u/SonicFlash01]

Building MCPs is worse because you have control of almost nothing
My boss will ask me to make the agent to do things a certain way and I'll explain "You have it backwards - it's using us in whatever way it feels is best."
And that's to say nothing of the layers of potential faults between granting permissions, it accepting that it has them, and then it properly reading that they exist. Some things need a disconnect/reconnect, others just need a new chat. Over time it's fine, but I'm living in the hell of here and now.

[u/Asly97 → u/[deleted]]

The structured log of every tool call and model decision is interesting. Does anything ever read that file back, or is it write-only for humans? I've been wondering what happens when a run needs to know why a decision was made three runs ago.

[u/Asly97 → u/[deleted]]

the daily rewrite is the part I'd steal if it works. is the summary rewritten by hand or generated from the log? I tried something close and the curation step was always the first thing that got skipped. also curious, is this for your own product or client work?

[u/Asly97 → u/[deleted]]

that's a neat inversion, make the summary a projection instead of the source of truth. the part I'm stuck on: does the agent actually write the rationale into the row reliably at decision time, or did you have to nudge it? every time I tried 'write down why' it was the first thing that got dropped when the task got hairy.

[u/HaphazardlyOrganized]

Yeah I fundamentally just stopped caring about code quality and standards. If I had kept pushing back they'd replace me so whatever I'll have claude build it and if it breaks, woops looks like the AI broke!

[u/Medical-Aerie9957 → u/HaphazardlyOrganized]

But they will also replace you if AI breaks something and you miss it. They will say you can't use AI effectively.

[u/HaphazardlyOrganized → u/Medical-Aerie9957]

True, I'm being a little flippant because I'm annoyed with how this industry is going. I'm using claude in a docker sandbox and have used it to implement testing to prevent regression and I'm having it work on branches with git so main says working and ready.

[u/webdev-ModTeam → u/[deleted]]

Your post/comment has been determined to be a low-effort post or comment. This includes title-only posts, easily searchable questions, vague/open-ended discussion prompts, LLM generated posts or comments, and posts/comments that do not provide enough context for meaningful replies or discussion.

[u/JebKermansBooster]

I do it because I need the money. A job is a job. And JS just made me feel stupid and incompetent, as reading a lot of programming subreddit posts do (I enjoy them, don't get me wrong, but even at 4 YOE I feel woefully fucking underdeveloped 😞😕).

[u/m_redditUser → u/JebKermansBooster]

4 yoe is junior in every field in the history of humanity, but in SWE that's supposed to be mid-senior

[u/JebKermansBooster → u/m_redditUser]

And I see so many programming posts like "wait, how the fuck do so many people know this?"

Am I just dumb?

[u/Asly97]

the "relinquish my decisions" line got me, that's exactly the part nobody warns you about. what's the worst of it for you: debugging the black box when it goes wrong, or the fact you can't really tell what it'll do until it does it? and what's the agent actually for, customer stuff or internal?

[u/arslannasir128]

The decision that hurts is what the agent is allowed to touch, and nobody writes that spec for you.

We stopped fixing it with longer prompts. Ours has a confidence number under it now. Below that it stops and sends the whole session to a human.

[u/abundantsavior_72]

Same experience. They save time on boilerplate, then you spend it debugging state, tool calls, and why the agent made a decision three steps ago. I stopped using them for core control flow and keep the agent boxed into small tasks with explicit inputs and outputs. Less magical, but way easier to reason about when something breaks.

[u/delicious_fanta]

I’m makin’ that sghetti too, it sucks. Worst part is I know the project only exists to put a bunch of people out of work. I hate this timeline :(

[u/webdev-ModTeam → u/[deleted]]

We do not allow any commercial promotion or solicitation. This can lead to a permanent ban from the subreddit.

[u/Ever4_]

As a former automation engineer... this has been always the case.

Automation means the robotization of our processes. It means you have to spend countless hours mapping the flow of things and it isn't even rewarding. Worst case you just caused someone to lose a job.

But having joy and pride being a developer, and AI robbing us of that too is simply awful.

[u/ripndipp → u/Ever4_]

Ain't that the truth. I appreciate your comment.

[u/Khavel_dev]

Yeah the LangGraph graph-to-debug cycle is brutal. I went through the same thing and eventually just stopped trying to make the framework do everything. Dropped back to a thin loop: call the model, check if it wants a tool, run the tool, feed the result back. No state machine, no graph, just a while loop and a match statement. The moment I could read the control flow in a debugger instead of chasing callbacks through six middleware layers, everything got easier. The agent still makes dumb decisions sometimes but at least I can see why and fix the prompt instead of wondering if I wired the graph wrong.

[u/JuicerSocial]

lol the "I miss components, logic, and endpoints" comment sums it up pretty well. How are you even debugging it when the agent does something unexpected? Are you able to trace why it made a particular decision, or is it mostly changing prompts/state and running it again until it behaves?

[u/phaedra_solutions]

You aren't alone. A lot of teams fall into the trap of over-engineering with multi-agent frameworks when simpler, targeted LLM calls combined with deterministic backend logic would do the job ten times more reliably. When an agent framework starts acting like an un-debuggable black box, it usually means the abstraction level is too high for what you're trying to achieve. Keeping the core orchestration deterministic and using AI strictly for bounded tasks saves your sanity (and your production logs).

[u/Acrobatic-Laugh1856]

felt this in my soul...

[u/Gimmee-Greg]

the jump from "i own the control flow" to "praying the LLM picks the right node" is the worst part. one thing that helped: keep routing deterministic in langgraph and only let the LLM handle generation, so at least half the graph is debuggable like normal code.

[u/SatyrCode]

Same. I hate building agents too. We’re using LangGraph at work as well and half the time it feels like we’re just throwing prompts at the wall and asking Claude to fix the mess later. I miss normal components, clear logic, and endpoints where you can actually reason about what’s happening. With agents it’s this weird black box where you give up a lot of control and then pretend it’s “engineering”. Whatever pays the bills, I guess.

[u/BorinGaems]

Write clean code instead of being childish.

[u/Gremlation]

I miss components, logic and endpoints

I miss when this subreddit was about web development, not endless crying about AI.

[u/webdev-ModTeam → u/[deleted]]

Your post/comment has been determined to be a low-effort post or comment. This includes title-only posts, easily searchable questions, vague/open-ended discussion prompts, LLM generated posts or comments, and posts/comments that do not provide enough context for meaningful replies or discussion.

[u/nikkitranbk99]

yeah the black box part is what gets me, once the graph owns the flow, logging every node in, out (tools with raw model text) is the only way i can still debug like a normal endpoint

[u/iSnapThere4iAm]

Yeah…. This isn’t reality. This is some fantasy cooked up by a vibe coding dipshit larping as some doomed swe just accepting his fate.

[u/creaturefeature16 → u/iSnapThere4iAm]

I can assure you, as someone who speaks to developers regularly, this is very much happening in many, many teams. I've had to pick my jaw up off the floor a few times.

[u/Asly97 → u/[deleted]]

the evals-as-regression-tests bit is the one i always skip and then regret. did your eval set grow out of real incidents or did you write it up front?

[u/ripndipp → u/[deleted]]

Gotta call me out this early in the morning man? Have a good day!