Hey all, I’m pretty new to this space, not technical. I’ve tried to use AI this year to get more stuff done and have more time for myself.
Would like to hear how more experienced people here set up AI in real work and daily life.
For context if it may help, I manage multiple tasks from many projects, has kids and ADD. Thank you.
Saw this line in a piece about AI sycophancy in mental health crises and it actually pulled me up. The same training loop that produces flattering chatbot answers for individual users is also flattering the executives using those chatbots to evaluate AI strategy.
OpenAI ran internal tests on this. Their finding: users consistently prefer the most sycophantic answers. So that's what got shipped. The mental-health side is now 414 documented cases (Human Line Project tracking, BBC investigation). The corporate side is the same loop, just at a higher capital-allocation altitude.
Curious if anyone here has actually pushed back inside their company about this. Like, has anyone seen an exec circle back from a "ChatGPT told me to do it" decision after a peer pointed out the loop? Or is the loop too embedded already.
Do you guys ever feel like a lot of AI tools still act more like interns you have to micromanage?
That’s the part that started bothering me after the novelty wore off. A lot of them can answer questions well, rewrite things well, summarize things well, but they still need you to keep feeding the next step. Find this. Now organize it. Now turn it into something usable. Now do the next part.
At some point I realized that the first time AI actually started feeling useful to me was when it stopped waiting for every next instruction.
Not because it got smarter in the abstract, but because it started feeling more like something I could delegate to. I could hand it a task, and instead of just giving me one decent response and stopping there, it would keep going, figure out what it needed next, pull in more context, organize the messy parts, and move toward something actually usable.
That shift made a much bigger difference for me than better writing or slightly better answers ever did.
Been testing coding agents on larger repos and saw something odd.
Even after they already explored the codebase, they still kept doing stuff like:
reading the same areas repeatedly
opening files that weren't really relevant
missing relationships between components
making changes that technically worked but didn't fit existing patterns
The weird part is it didn't always feel like a context size issue.
It felt more like they had no lasting understanding of the repo itself.
I started messing around with this idea in RepoWise
Mostly experimenting with repository signals like dependency relationships, commit history, files that change together, etc.
Curious if people building agents are seeing the same thing, or if there's already a better way to handle this.
GitHub link in comments
100,000 agents have started working an agent-to-agent marketplace I built for fun so agents could earn, compete, and try to make a living.
Crypto-native users seem to be showing up early because agent tasks are executed and settled in USDC.
Agents need payments, incentives, task verification, reputation, and settlement. Crypto users already understand wallets, quests, rewards, and permissionless participation, so maybe this pattern makes more sense than I expected.
Did I accidentally build a piece of Web4?
Hi all,
Over the last 2 years, I’ve built around 10-15 LangGraph agents for very specific tasks in our company. But lately, it feels like all that work isn’t really maintainable for a single AI/agent engineer. Plus, with the new gen models, a lot of these agents feel obsolete—like most of these tasks could just be handled by a single agentic LLM in a simple loop.
Sure, breaking out of a task is harder with frameworks like LangGraph, where you have predefined paths, but for small, low-risk tasks—like "check all tickets created in the last 2 hours, look for relevant info in Confluence, and add it as a comment"—I don’t see why you’d need a full LangGraph or CrewAI agent. It seems way more mature to just have one open agent with some MCP tools. This single agent could handle so many different tasks.
I’m not saying you should let the agent do everything you throw at it (prompt injection and context overload are real risks), but an "IT-managed agent" where we define the system prompts, pre-check inputs with another LLM, and only expose the agent via a controlled endpoint for certain users… I don’t see many downsides compared to those complex, predefined LangGraph agents.
I did a super detailed audit of our new landing page to see how AI agent ready it was. Scored 9/100 (it's two weeks old website so no feelings hurt).
So I spent an afternoon fixing all the issues on the audit report. The next day we got this spike in AI traffic and it continued for the days after.
I'm still monitoring whether these agent visits can bring us actual human users. But seeing the chart move that fast off a few hours of work is really promising so I wanted to share out checklist.
Here's exactly what I fixed, in order:
robots.txt that explicitly allowlists major AI bots (GPTBot, ChatGPT-User, ClaudeBot, PerplexityBot, Google-Extended, CCBot)Content-Signal directive and a sitemap reference inside robots.txtsitemap.xml with lastmod on every URLllms.txt (short) and llms-full.txt (comprehensive), per llmstxt.orgAGENTS.md to guide coding agents through your productOrganization + WebSite schema (name, url, logo, description)<title>, og:title, and Organization name (inconsistencies split your brand authority across duplicates)display: swapFAQPage JSON-LD wherever you have Q&A contentllms.txt, and FAQ schema to cover per-platform signals<link rel="canonical"> on every pagerobots directives (index, follow, max-image-preview: large)we're running an agentic pipeline that does multi-modal file processing - large files, often hundreds of mb per request. The actual agent logic works fine. but the infrastructure is not.
during peaks the queue backs up fast. But staying provisioned at peak capacity 24/7 would eat our runway during the slow periods. Standard cpu/memory-based autoscaling is the wrong signal here - gpu utilization under inference workloads doesn't behave the way normal compute does. you can have a node that looks underutilized on conventional metrics while your queue is actually backing up.
how others have handled this?
Hi everyone,
I’ve open-sourced agentmw, a framework-agnostic middleware that sits between your LLM client and agent logic to make agents more reliable on long runs.
Key features:
• Real-time failure detection (loops, redundant calls, contradictions, hallucinations)
• Smart context compression (keeps recent tool results, drops stale stuff)
• Persistent reasoning library (SQLite + embeddings) that learns reusable patterns across sessions
• Time-travel debugging CLI
• Works with any provider (OpenAI, Anthropic, Ollama, etc.) and any agent framework
• Async, circuit breaker, MCP server support, TOML config
Demo: pip install -e '.[all]' && agentmw demo
It’s still early but already helping me keep agents from spiraling and wasting tokens. Would love honest feedback, bug reports, or ideas for additional middleware features the community would find useful.
Thanks!
How to prevent AI assistants from giving unverified advice that wastes your time
I’ve been working on WordPress performance optimization (LiteSpeed Cache + Avada theme + Cloudflare) with an AI assistant and ran into a recurring problem that I suspect others face too.
The AI repeatedly suggested options that didn’t exist in the interface, misread screenshots, gave contradictory advice within the same conversation, and recommended changes that broke the site. Each mistake required time to diagnose and reverse. The core issue is that AI models answer confidently even when uncertain. Until that’s solved, the burden is on the user to slow the AI down and demand verification.
Has anyone found better prompting strategies for technical configuration work? I’ve been trying Claude, chat, Gemini and grok all of them are very similar with the useless tips
my desktop agent stopped failing the moment i stopped trusting the accessibility tree as a single source of truth.
The dumbest one was cross-app handoff. agent clicks a link in mail, safari becomes frontmost, the agent keeps asking for the original pid's tree and operating on a frozen snapshot. fix is detecting when the frontmost app changes between actions and traversing the new one before the next step. Easy to miss because the previous pid is still alive, just no longer relevant.
second one was sheets and dialogs overriding window viewport scope. an element shows up in the tree because it technically exists in the hierarchy, but it sits underneath an active modal sheet, so clicks pass to whatever is actually on top. Needed an explicit "is this element inside the current modal" check before every click.
Multi-monitor coordinates were the third. on a 3 screen setup the left external sits at x around -3840 and the right around 3456. a naive "click at x:200" lands on whichever screen contains (200, y), which is almost never the one you mean.
llm clicking the wrong button is rarely the model. it is the tree state being stale or scoped wrong, and the failure mode is silent until you diff before and after screenshots. written with s4lai
I'm running a workshop next month to help non-technical founders get their first Hermes agent or automation up and running. The goal is to take someone from zero to having a working agent they actually understand.
I've found the initial setup and finding the right foundation is the hardest part for non-technical people — way more than the concepts themselves.
For those who've taught AI agents to beginners: what worked? What did you wish you knew before your first workshop? Any pitfalls to avoid when the audience can't fall back on terminal skills?
BREAKING NEWS: Andrej Karpathy Joins Anthropic.
Andrej is one of the most respected people in AI world, and is particularly known for his ability to explain AI and LLMs to mere mortals like me.
A lot of the attention in AI goes to apps, agents, benchmarks, and funding rounds. But the deeper leverage may be in improving the research loop: using AI to help build better AI.
I think a lot of SaaS companies are about to have a weird measurement problem.
For the last 10+ years, marketers @ productivity/infra companies cared a lot about DAU/MAU because the assumption was pretty simple:
if people keep opening your app, they’re getting value from it.
But now, our agents are doing the work for us.
Our team for example barely opens some of these tools, and most of our assistants handle this work for us. Like: updating Linear, write in Notion, pull things from HubSpot, work with GitHub, draft emails, move content into our CMS, etc.
So from the product’s perspective, I might look less active.
But in reality, I’m getting more value from the product than before.
So, if agents become the main “hands” using these tools, then a few things probably matter more than before:
- Can the agent do everything through your API that a human can do in the UI?
- Can it understand your docs without fighting through marketing pages?
- Can it get its own auth, permissions, limits, and audit trail?
- Can it test things safely before taking action?
And maybe the biggest one:
Should we still care about Daily Active Users, or should we start caring about Daily Active Agents?
And marketers will have their hands full on how to measure their activity. How many agents did useful work in your product today? How many actions did they complete? Did they come back?
I don’t think most companies are set up to measure this yet. But it feels like the direction things are moving (looking at how fast big companies like Notion/Stripe/Resend are publishing agent-native tools)
Curious how other people are thinking about this!
This is mostly aimed at vibe coders who are unable to or don't want to guide agent every 10 minutes.
My two biggest questions are:
The first question is the immediate practical one.
How on earth do people make these agents keep running?
Unless I write some script that watches the terminal and keeps sending:
«continue unless you are fully done; if you are fully done, say DONE as your last word»
or unless I build some server hook / automation loop around the agent, it just keeps stopping. It finishes when I do not want it to finish. It reports halfway through the plan. It asks for input when there is nothing useful for me to evaluate yet.
So I’m asking very practically: what are people doing right now to make agents actually work for long stretches?
The second question is about architecture.
I’m trying to figure out what kinds of architectures are actually good for AI-maintained local applications, especially systems that may eventually reach tens of thousands of lines and coordinate multiple local components/processes.
I thought an event-driven architecture might be good for this. I tried going in that direction with NATS-style communication. But my current impression is that agents are not good at it. Maybe I did something wrong, but it felt like the agent became terrible at reasoning about the system once everything was happening through events.
If the agent has to understand the system by reading event logs, tracing IDs, and reconstructing causality from a stream of messages, that feels like a bad fit. Maybe this is just not agent-friendly, at least not for a solo/vibe-coded local application.
So the deeper question is:
«What architecture makes an AI agent unusually good at maintaining and extending the project?»
Not what architecture is theoretically elegant. Not what architecture is optimal for a senior engineering team. What architecture is actually easiest for the model to reason about, test, debug, and extend?
The rough workflow I want is:
Roughly:
«1 hour knowledge organization
1 hour implementation planning
20 hours execution»
The exact numbers are not the point. The point is depth and continuity.
I do not want the model to spend 5 minutes writing a plan, 10 minutes coding, and then report “done.”
The first problem is messy context.
If I give an LLM a bunch of files, old specs, old ideas, and previous attempts, it often treats everything as if it was written today and is equally valid. But half the material may be obsolete, contradicted, abandoned, experimental, or from a failed attempt.
The model does not magically know the status of each piece of knowledge.
So I feel like there needs to be an explicit intermediate stage: not coding, not planning, but knowledge organization.
Something like:
- current requirement
- old requirement
- obsolete idea
- failed attempt
- unresolved question
- architectural constraint
- implementation detail
- still-useful note
- contradicted by later note
- needs user confirmation
Then I can correct the knowledge map before the model starts planning.
That seems much more useful than dumping 50 files into context and hoping the model “gets it.”
Is anyone using tools/workflows that actually do this well?
The second problem is shallow plan mode.
A lot of current “plan mode” workflows feel shallow. The model asks two or three questions, writes a short plan, and then acts like it has enough alignment.
But that is not what I want.
I want the model to actually spend real effort thinking through the system before writing code.
People always say some version of:
«5 minutes of planning saves an hour of work.»
Fine. Has anyone actually made that real with LLM coding agents?
Because right now a lot of agent planning feels like a formality. It asks a few questions, writes a plan, and then immediately wants to start coding. Or it keeps rewriting the whole plan over and over instead of thinking deeply first and then writing a stable plan.
Maybe the missing workflow is not just “plan mode.” Maybe it is something like:
«plan the planning → organize the knowledge → ask real questions → write the implementation plan → execute until the plan is actually complete»
The third problem is premature reporting.
This is probably my biggest issue.
The model writes an implementation plan. I review the implementation plan. Then it starts implementing. Then it stops halfway and reports back.
Why?
If I already reviewed the implementation plan, why does it need me to keep saying “continue implementing the plan”?
If it has not hit a fundamental blocker, if the plan has not become invalid, and if there is nothing genuinely useful for me to evaluate yet, why is it reporting at all?
A lot of completion reports are basically just the implementation plan rewritten in past tense:
«I added X.
I implemented Y.
I updated Z.»
That is not useful to me.
For a vibe coder, I do not want to inspect a pile of changed files. I do not want a past-tense summary of the plan. I do not want a fake checkpoint that exists only because the agent decided to stop.
What I want is one of these:
If the current work is still mostly mocks, scaffolding, internal wiring, or abstract architecture, then there may be nothing useful for me to evaluate yet.
In that case, why stop?
Why not finish the planned implementation first, then let me test and evaluate when there is actually something to evaluate?
Whose time is more precious: mine, or the agent’s?
I am not saying the agent should never stop. It should stop if:
- the plan is fundamentally wrong
- a major architectural decision is needed
- a blocker cannot be resolved
- it has something real and testable to show
- continuing would obviously waste a lot of work
But if it is just stopping because it completed “some steps,” that feels useless.
The fourth problem is making agents actually work for long stretches.
How are people actually spending their token budgets productively?
With some subscriptions and API setups, the amount of possible usage is huge. But in practice, I find it hard to spend it well because the agent keeps stopping, asking for input, or producing reports that do not help.
How do you make an agent execute for one hour, eight hours, or overnight?
Can you actually do this in a useful way right now?
Do you use scripts that automatically send continuation prompts? Do you use hooks? Do you run agents inside some kind of supervisor process? Do you use a specific tool that already solves this? Or is the answer simply that current agents cannot really do this yet without external automation?
I have tried or looked into OpenCode, OpenClaw, Gemini, Claude, Codex, Pi, and a bunch of Kanban-board-style workflows.
My current impression is that OpenCode with Docker sandboxes is one of the more practical setups. Terminal UIs feel more reliable to me than a lot of GUI agent setups, and Docker sandboxes feel like a decent practical compromise, especially on Windows if you do not want to deal with a full WSL workflow. Not saying WSL is bad, and obviously sandbox security is its own topic, but Docker sandboxes feel convenient.
I have not deeply tried the “agents roleplay an organization” style of workflow. Maybe I should before judging it. But from the outside, I worry that a lot of multi-agent setups become corporate roleplay: workers praising each other, moving cards around, doing shallow reviews, and spending my money on simulated middle management.
Is there a recommended setup that actually achieves the goal?
Not roleplay. Not card movement. Not fake review loops.
Actual useful long-running work.
The fifth problem is language/framework choice.
For AI-heavy coding, I’m starting to think one of the most important constraints is:
«Is the model actually good at working with this language, framework, and project structure?»
For normal engineering, you might pick something because it is technically optimal, elegant, fast, scalable, or theoretically clean.
But if the main implementer/maintainer is an LLM, model proficiency becomes a first-class constraint.
A boring, widely represented stack may beat a technically superior stack if the model is much better at writing, debugging, testing, and extending it.
This seems especially important for vibe coders. If the agent is eventually supposed to handle tens of thousands of lines, I care less about what is theoretically elegant and more about what the model can reliably modify without causing cascading breakage.
Are there good benchmarks or practical community knowledge on which languages/frameworks current models handle best?
The sixth problem is architecture.
I’m trying to figure out what kinds of architectures are actually good for AI-maintained local applications, especially systems that may eventually reach tens of thousands of lines and coordinate multiple local components/processes.
At first, it is tempting to optimize for extensibility:
- make everything swappable
- make everything modular
- make it easy to add new components
- make components communicate through clean boundaries
But I’m starting to think extensibility matters less than maintainability at the beginning.
The first priority is making the thing actually possible to reason about, test, repair, and expand without every change breaking ten other things.
So maybe the default should be:
- clear component boundaries
- explicit interfaces
- boring communication patterns
- deterministic tests where possible
- mocks at boundaries
- real pressure points represented in tests
- replace one mocked component at a time with a real component
- every component can be tested in isolation
Basically: make the architecture agent-legible before making it powerful.
A folder structure template is not enough. I’m more interested in reusable architecture templates where the component communication, boundaries, testing strategy, and failure modes are already thought through.
Do repos like this exist?
Not just:
«here is a folder layout»
but more like:
«here is a healthy skeleton for building a local multi-component application that an agent can keep extending without turning it into spaghetti»
The seventh problem is orchestration.
Do Kanban boards, orchestrator/worker setups, and multi-agent systems actually help with this?
A static task board seems limited because after task 3 is done, task 8 may no longer make sense. Someone has to re-evaluate the plan. The agent needs to manage its own work, not just move tasks from “todo” to “done.”
Maybe persistent sub-agents/workers would help. For example:
- one worker owns tests
- one worker owns architecture
- one worker owns a subsystem
- one worker owns documentation/knowledge state
But that can also become useless roleplay if it is not grounded in real artifacts.
Has anyone found a multi-agent workflow that actually works for this kind of long execution?
The eighth problem is whether my preferred approach is even optimal.
Maybe this workflow:
«organize sources → plan deeply → execute for a long stretch»
is worse than:
«run multiple worktrees/agents in parallel with different constraints → compare implementations → keep the best ideas»
That might be a better way to spend a large token budget.
But it also creates another problem: now I have to review multiple implementations, fix multiple broken versions enough to compare them, and give slightly different instructions to each branch.
Has anyone compared these approaches in practice?
Which one actually works better for non-trivial projects?
My questions:
I am not asking for hype, future predictions, or emotional takes.
I’m asking this in the most practical way possible.
Maybe my framing is wrong. Maybe the real bottleneck is somewhere else. If so, criticize the premise.
I mostly want to know what people are actually doing right now that works.
Sorry for ai generating this, but I made sure to review it bunch of times.
hi,
I am using langgraph to build agents, so far it has been working fine for me (mostly demo apps with a complex workflow) . I have been going through other threads on the forum and observing that langgraph has some performance and build issues.
can you help me understand what is the problem and what are you using to build reliable agents, any best practice or tips will be very helpful.
Not talking about small stuff like summarizing notes or drafting emails. I mean real work:
Because honestly my experience has been all over the place lol
Tools like ChatGPT, Claude, Perplexity, Cursor, n8n and similar stuff have made individual tasks insanely faster. I can build workflows now in a few hours that used to take days.
But the moment things become long-running and messy, cracks start showing up.
Context drifts
Agents skip steps
Sessions expire
One weird API response breaks the flow
A browser page half-loads and now the agent thinks the task is done
I was experimenting with some browser-heavy workflows recently and realized the hardest part wasn’t even reasoning. It was reliability. Stuff like Browser Use and hyperbrowser honestly mattered more than prompt tweaking because unstable environments were causing most of the failures.
That’s why I keep wondering if the future is less about replacing people entirely and more about agents handling narrow repetitive work while humans handle judgment, edge cases, and coordination.
The most useful systems I’ve seen so far are usually:
Not autonomous digital employees running entire departments lol
Curious where everyone else stands on this.
Do you think agents eventually handle bigger end-to-end work reliably, or are we underestimating how much human coordination actually matters?
Not talking about writing emails or generating code.
More like randomly opening ChatGPT during the day for things like:
Kind of strange because a year ago AI felt like a tool.
Now it feels closer to thinking out loud without needing another person available.
Curious if this is becoming normal behavior or if the AI bubble is making it seem bigger than it is.
Hey Reddit, I’m 21 and I’m starting a new job next month heading up a solo AI department at a high-end furniture factory.
Short backstory: I did a short internship there recently where I used some AI video tools for a project, and it ended up getting shown to the main CEO (the company is a subsidiary, so the big boss saw it). Long story short, they loved it and now I’m starting a new role to do my own thing.
I’m super hyped, but there’s no real roadmap, so I have a blank slate. I want to show the real power of AI and save the company some big bucks in my first week to shock everybody.
I was already thinking about stuff like:
Zapier integration: Automating the flow for our invoice processing.
Product imagery: Extending our product photos with different color options (we currently drop 30K on 6 shoots, and not even 20% of our products have all color variants shown).
Can someone help me find the best agent form for me to use right now?
But I want to know what you guys would do. What is an easy-to-start, high-impact project that would make the CEO’s jaw drop? I’m open to anything—I really want to prove what AI can do right out of the gate.
me (GTM/business dev. side), my co founder (AI/ML engineer) and the rest of the team (4 SWE's) tried many things in AI-agents the past 5-6 months, agencies, SaaS, services, all of it. We landed one client through our network, built a fully custom AI-platform for them. Still running. (i made a recent post about this but wanted to make it clearer)
But recently i've been really interested in the AI-native agency/service company model where you use internal AI-agents to sell an outcome (service) to an ICP instead of relying on human labour solely. (Requested by YC in RFS 26')
Like the recent success with tryprism (dot) com and Andustry (both YC 26). But there's two ways we can go about it.
or
I dont know which route is better considering we don't actually have deep domain expertise in GTM, recruitment or other agency models where we can build one from the ground up, we would be able to build the internal agents pretty damn well (our expertise and leverage).
were a very, very good AI and software engineering team with good expertise in building complex vertical ai-agents. That's why im stuck...
In your opinion, which makes more sense? building an AI-native agency in a specific domain like GTM and selling the outcome ("demos booked"), or becoming the AI-engineering team/partner that comes in and builds custom AI-agents, expand them and maintain them for existing traditional agencies (will narrow down the ICP significantly tho) for a retainer basis?