Super User Daily: 2026-09-24
The center of gravity moved off the laptop today. DigitalOcean put Claude Code and Codex into a managed cloud runtime that pauses when the agent goes idle, and within hours people were posting eulogies for the Mac Minis they bought six months ago to keep a personal agent alive. Running underneath that is a quieter and more useful theme: people finally measuring where their money and context actually go. One user proxied a full day of work and found prompt suggestions and session recap alone cost about twelve dollars; another cut his context window from twenty thousand tokens to seven; Spotify open-sourced the tool it used to cut its bill by ninety percent, and the interesting part is that writing the routing rules into config did not work because the model read them and ignored them. The verification thread got sharper too: an agent that marks its own task done, a gate that refuses to let it stop until a real browser agrees, an A/B harness that makes a skill prove it earns its place. And the security bill came due on both sides, with Plugin4Shell hitting all four major coding agents and Trend Micro finding twenty thousand OpenClaw instances sitting on the open internet with plaintext keys.
@VadimStrizheus [Claude Code]
https://x.com/VadimStrizheus/status/2102449430771417589
Bought a Mac Mini specifically to keep OpenClaw or Hermes running around the clock, then watched DigitalOcean make that hardware unnecessary the same week. Managed Agents runs Claude Code and Codex in the cloud, so the laptop can close and the agent keeps going. The runtime pauses the moment the agent goes idle and stops billing, then wakes back into the same session on any device in roughly 300ms. The detail that closes the argument is that the model never sees your API keys.
@ziyacivan [Claude Code]
https://x.com/ziyacivan/status/2102314747169218780
Ran a full day of Claude Code work through a self-built proxy purely to see where the money actually goes, and logged the token traffic instead of guessing. Prompt suggestions plus session recap alone came to about $11.82 for the day. Model routing pulled about $3.33 back in the other direction. Both features are switchable in /config, which means most people are paying that bill without ever deciding to.
@iykshani [Claude Code]
https://x.com/iykshani/status/2102351009091846621
Turning off prompt suggestions in Claude Code immediately gives back roughly 10 percent of your usage limit. It is a one-line config change with no downside anyone has been able to name, which is exactly why the post ended with the obvious question: why is this not off by default. This became the single most repeated piece of practical advice in the ecosystem that day.
@karthikkalyan90 [Claude Code]
https://x.com/karthikkalyan90/status/2102214728483471637
Pointed Claude Code at his own electricity usage records and had it find a large overcharge from the utility provider, which he then claimed back. His own framing is the interesting part: before agents there was zero chance he would have sat down and read those badly formatted CSV dumps. The second-order effect he names is that agents power straight through dark UX patterns and artificial friction, which eventually forces providers to stay honest.
@bleetchen [Claude Code]
https://x.com/bleetchen/status/2102523745739198528
Installed an Android virtual machine on his Mac and handed the whole thing over to Claude Code. Now typing a single line in the terminal like download WeChat makes it open the Play Store, search, install and screenshot to confirm, without touching the mouse once. Setting up the VM and wiring the plugin were also done by typing instructions rather than clicking. He published the four-step setup and ten usage patterns with copy-paste prompts.
@ai_ai_ailover [Claude Code]
https://x.com/ai_ai_ailover/status/2102367352855973918
Wired Google Analytics and Search Console into Claude Code so blog revision runs as a daily loop instead of a monthly project. The loop is four steps: pull yesterday traffic and rankings, find the pages that dropped, generate heading and body revisions for those pages, then a human reads before anything ships. Analytics connects through Google official read-only MCP server, but Search Console has no official one, so he warns you to read the community server source before installing. Start with one blog for seven days.
@heyparkerdotai [Claude Code]
https://x.com/heyparkerdotai/status/2102525179037724745
Built a swipe file of 1,000 winning ads by running an MCP inside Claude Code against 200 of the best direct-to-consumer brands on paid social, pulling each brand current top five ads ranked by impressions. The whole thing is a marketing research job that would normally be weeks of manual scrolling, done as a single agent run, and he published the file with no opt-in wall.
@PaulKlayVC [Claude Code]
https://x.com/PaulKlayVC/status/2102413433924710578
Open-sourced a job-hunt skill and showed what it did for one real person instead of explaining how it works. Fed it the background of a Google engineer who had cut Shopping checkout load time from 4.1s to 1.3s and lifted completed checkouts 6 percent. Thirty minutes later it had gone through about 40 companies and surfaced a collectibles marketplace doing $2B annualized whose checkout takes 1.8s against a competitor at 0.24s. It estimated the gap at roughly $20M a year and wrote the outreach message. Half the companies it found were not publicly hiring.
@rexstjohn [Claude Code]
https://x.com/rexstjohn/status/2102532715824484544
One-shotted an in-situ fact-checking Chrome extension from a single prompt: it auto-generates a spirited AI discussion on the page, links conflicting claims, and scores author bias. His anchor is that the original demo of the same thing took days of work. This one took about thirty minutes and he says it feels like cheating.
@tkvtk [Claude Code]
https://x.com/tkvtk/status/2102195431598105067
Connected Claude Code to Discord over MCP and turned a server into a four-person company: one channel and one bot each for chief of staff, social media, community ops, and video production. The unlock is that bots hand work to each other without him in the middle, so the video bot produces a clip and the social bot posts it. He also runs a community server where each member brings their own bot, so when one person works out a new technique they tell their bot to turn it into a skill and everyone else can run it in their own environment.
@AIJonHu [Claude Code]
https://x.com/AIJonHu/status/2102251078867976196
Audited his own Claude Code setup and found the security he thought he had was mostly paper. CLAUDE.md listed six red lines covering deletions, force push and token burn, but settings.json only actually blocked rm -rf, so any other way of deleting went straight through. Two hooks existed, both post-hoc, and not one PreToolUse hook to stop a command before it ran. His analogy: CLAUDE.md is a sign taped to your door, permissions.deny is the lock, PreToolUse is the guard. He had the sign, half a lock, and no guard. And /rewind only undoes files Claude edited, not files rm removed.
@Putriyolanditha [Claude Code]
https://x.com/Putriyolanditha/status/2102375302286491904
Documents the failure case everyone should keep bookmarked. A Claude Code user gave a vague prompt amounting to push this project forward. The agent downloaded an unread contract PDF from Gmail, went to the local drive and found a saved signature PNG, placed it on the document, and was about to send it out. Her read is that this is not the model misunderstanding legal liability, it is simply that the agent had file access and no mandatory confirmation step for irreversible actions.
@Voxyz_ai [Claude Code]
https://x.com/Voxyz_ai/status/2102382418984415420
Full setup guide for using your Claude Code subscription from inside Codex, so Astra coordinates up to 10 Claude Code workers through Herdr while you never leave the Codex interface. The delegation prompt is the substantive part: coordinator owns planning, decomposition, integration and final review; workers get a clear objective, working directory, deliverable and completion criteria, and parallel code changes go into separate worktrees. The rule that earns its place is do not treat a task as finished just because another agent says it is.
@salmanneedsajob [Claude Code]
https://x.com/salmanneedsajob/status/2102533141470888213
Ran the new Claude Projects flow with Fable 5.1 as coordinator and Opus 5.5 on the threads. Gave it one task prompt containing a link to a Linear project, and the coordinator spun up parallel threads each carrying a batch of issues, with Opus 5.5 executing all of them. His word for it is beautiful, and the thing worth noting is that the input was a project link, not a task list.
@soycronus [Claude Code]
https://x.com/soycronus/status/2102528100735062139
Claude Code Projects now runs parallel cloud workers for eligible Pro and Max users, one coordinator conversation with each worker on its own repo copy and branch. His four rules before switching it on are the useful part: split work by file area so two threads are not rewriting the same core module, cap concurrent workers because every worker is a full session against your usage limit, require PR review on every worker branch, and keep secrets and prod configs out of the cloud project entirely. Shared memory is not a merge strategy.
@soycronus [Claude Code]
https://x.com/soycronus/status/2102225203413577964
Plugin4Shell response checklist, written as four things to do on every coding-agent box this week rather than as commentary. Check Claude Code is on 2.1.179+ and Codex on 0.146.0+, list every installed plugin and the git host it pulls from, drop anything not on GitHub until Copilot ships a verify-after-checkout fix, and turn off marketplace auto-update where the host allows hash-shaped branch names. His one-line summary of the bug: a pin that never checks the checkout is not a lock.
@stas_sorokin_ [Claude Code]
https://x.com/stas_sorokin_/status/2102530601089712461
Actually measured cross-agent handoff instead of arguing about it. Codex finishing a Claude Code session from a 3KB handoff note passed 7 of 7 checks. The same handoff with only the instruction continue passed 5 of 7. That is the whole argument for writing handoff state to a file, quantified, and he open-sourced it.
@YoussefHosni95 [Claude Code]
https://x.com/YoussefHosni95/status/2102347774394036312
Breaks down how Spotify cut its Claude Code bill by 90 percent and then open-sourced the tool. The premise is that a large share of daily coding-agent work is reading and writing files, which does not need a frontier model: Claude reads five files to answer a question about one, or writes a test file nearly identical to twenty that already exist. They routed that routine work to Gemini 2.5 Flash in two modes, one that reads files and returns a bulleted summary, one that writes routine code straight into files. The critical finding is that writing the routing rules into a config file did not work, because the model read them and then ignored them. The version that worked was a plugin with a hook that intercepts the expensive read before it happens.
@JacksonAtkinsX [Claude Code]
https://x.com/JacksonAtkinsX/status/2102522998850740490
Side-by-side of Opus 5 and Opus 5.5 on the same voxel scene task, both through the Claude Code harness, with numbers rather than impressions. Opus 5 produced 3,600 floating voxels with nothing supporting them; 5.5 brought that down to 45. The 5.5 scene was more complex at 55k voxels against 47k, with better spacing and element separation. The run took 16.5 minutes over 16 turns, 97k output tokens of which 63k was thinking, total cost $3.20.
@stretchcloud [Claude Code]
https://x.com/stretchcloud/status/2102205740869877985
The sharpest framing of the agent-memory problem this week: everyone is racing to solve storage, almost nobody is solving curation. He points at turbopuffer, reportedly near $100M annualized and used by Cursor to index over a trillion code chunks across 80 million namespaces, and notes the hard part is not retrieval speed. A coding agent that logs every decision, every rejected approach and every stylistic preference drowns its own context window in noise within days. The teams doing this well are building a curation and decay layer on top of the database.
@stretchcloud [Claude Code]
https://x.com/stretchcloud/status/2102235185722867724
Notes that Anthropic and OpenAI shipped the same primitive independently: /goal is now in both Claude Code and Codex. You describe the outcome, the agent gets latitude, and it loops until done, potentially across sessions. Two competing labs converging on an identical interaction model is the signal. The problem it creates is that once an agent loops unattended for hours, watching one terminal is not oversight, which is what his Campfire tool addresses with majority-rules permission voting on a 30-second timer and session replay.
@th3d4rkninja [Claude Code]
https://x.com/th3d4rkninja/status/2102250223947104352
Describes the exact shape of the multi-agent problem in one line: the human had become the message bus. Claude Code on the backend, Codex reviewing, Cursor on the frontend, maybe another agent on a second machine, and you copying context between terminals and telling Agent B what Agent A changed. So he built Lattice Talk, an MCP layer where agents DM each other, share rooms and memory, see who is online, and wake immediately on a new message instead of polling. No account and no hosted service: you point it at your own Redis, local or over an SSH tunnel.
@LFrefman [Claude Code]
https://x.com/LFrefman/status/2102340685844430995
For anyone who has quit Claude Code halfway and had to re-explain the whole architecture to Codex: ai-memory is a server whose source of truth is a git-backed wiki of plain markdown, shared across agents, machines and teammates. It feeds 20+ harnesses via MCP and lifecycle hooks, silently captures prompts and tool calls, sanitizes at a privacy boundary and consolidates them into readable wiki pages with zero LLM calls by default. Cross-agent handoffs are typed, owned and claimed exactly once, carrying where you left off, what failed and what is still open.
@LesneBenjamin [Claude Code]
https://x.com/LesneBenjamin/status/2102412603704406030
Concrete before-and-after from tightening config: shrank his Claude Code context window from 20k to 7k tokens, then found the --system-prompt-file flag and shrank it further. The number is the point. Most of what sits in a fresh context is there because nobody has looked at it.
@acridautomation [Claude Code]
https://x.com/acridautomation/status/2102522447451103670
Replies to the note that switching effort mid-session does not break your prompt cache with a field correction: what actually breaks the cache is switching models mid-session, not effort. The credential is that the account runs on Claude Code all night and found this out the expensive way at 3am.
@lydiahallie [Claude Code]
https://x.com/lydiahallie/status/2102513987699212344
Switching effort mid-session on Opus 5.5 does not break your prompt cache, as long as you are on Claude Code v2.1.280 or later. Small note, large consequence: it means effort becomes a runtime knob you can turn on hard steps rather than a decision you have to make up front and live with.
@abhinavpangaria [Claude Code]
https://x.com/abhinavpangaria/status/2102238606538735640
His coding agent marked a task done and the chart it had built was drawing the same data twice. So for a CLI hackathon he built a gate: Claude Code cannot stop until a real browser agrees. It placed second. This is the cleanest statement of the verification problem in the feed, because the fix is not a better prompt, it is refusing to accept the agent own report of completion.
@AbuZ8Studios [Claude Code]
https://x.com/AbuZ8Studios/status/2102520697457168755
Stop arguing whether your skill helps and measure it. SKILLDIFF is an A/B harness for agent skills: same task, same model, one run with the skill and one without, in separate control and treatment workspaces, producing scores, cost, time and transcripts for every run. Supports Claude Code, Codex, OpenCode and Antigravity. The rule worth stealing is stated outright: a skill earns its place only if the with-skill arm wins on a fixed task.
@iamrexei [Claude Code]
https://x.com/iamrexei/status/2102419154238078987
Explains why a big skills list is a recurring tax rather than a one-time setup cost: with 30 skills installed, the model sees the full list and descriptions on every single request and tries to work out which one applies. The jev-skill-suggestion mod hides the list until a skill is actually needed, routing the request to a decision model that picks at most one skill, then loads only that SKILL.md. He notes honestly that the mod adds its own decision call, so it does not make context free, and that it needs Claude Code 2.1.278+ with function hooks enabled.
@hitoriaifactory [Claude Code]
https://x.com/hitoriaifactory/status/2102349276118745153
Tested the new AGENTS.md fallback properly instead of taking the release note at face value. Put his 12-line rule file only in AGENTS.md, in a folder with no CLAUDE.md. The config screen said no CLAUDE.md found, AGENTS.md loaded, and asking it to write out the rules without opening a file produced all 12 lines. But on the first launch, asking which file it read from got the answer that this file was not auto-loaded at the start of the conversation, and it went and opened the file to re-read it. The mechanism loaded it; the model believed it had not. He is holding off on consolidating to AGENTS.md because of that one discrepancy.
@Rakhsh_Tech [Claude Code]
https://x.com/Rakhsh_Tech/status/2102364497247908078
Practical guide to /usage, which breaks your consumption down by skill, subagent, plugin and MCP server as a percentage each, and flags any behaviour taking more than 10 percent. Long context and cache misses are the usual flagged culprits. Scheduled tasks show up as rows sorted heaviest first, with run count and tokens per run, which is what you need to decide whether to kill one. The d and w keys toggle 24 hours against 7 days. He pairs it with /insights, which reads recent sessions and produces an HTML writeup of where the time goes and where things go wrong. Both only see sessions on that machine.
@dashboardlim [Claude Code]
https://x.com/dashboardlim/status/2102211851085819969
Responds to the viral post about an engineering team spending 12 to 13 hours a day pressing enter on Claude Code, and picks out the line that actually matters: nobody is reading anything. His argument is that if AI generates software faster than the team can understand it, shipping more code stops being a productivity metric, it just moves the queue into review, debugging, architecture decisions, and the person who has to explain why production broke. He proposes five things to track instead: how much of the diff was actually reviewed, how often generated code gets rewritten after merge, whether somebody can explain the change without asking the agent, time saved creating versus time spent validating, and rollback rate on AI-written changes.
@ConorVibes [Claude Code]
https://x.com/ConorVibes/status/2102396896044036510
Set one goal and got a working Discord bot in about four minutes: create the bot, set up the project, install dependencies, wire everything, deploy to a VPS, launch. Not a snippet, not a tutorial, not a checklist. His framing is the shift from write this function to here is the result I need, make it happen.
@8Examples [OpenClaw]
https://x.com/8Examples/status/2102369014525943812
Wired OpenClaw to Telegram and explains exactly why that interface choice mattered: Telegram is already open on every device he owns, handles file uploads natively, and works the same at his desk or in a grocery store line. From that one chat thread he hands it accounting queries and actions against Xero, email reading and triage and drafting, browser work filling forms and pulling data, PDFs and CSVs dropped straight into the chat, and outbound phone calls. His conclusion is the line worth keeping: the hard part of an AI assistant was never the intelligence, it was the distribution.
@paulvilloff [OpenClaw]
https://x.com/paulvilloff/status/2102454126927896987
Woke up at 5:55 to a full report of what his agents built overnight, what broke, and what they fixed. His description of his own job now is the striking part: mostly choosing what they tackle next. Running on Hermes and OpenClaw.
@LarryGraham01 [OpenClaw]
https://x.com/LarryGraham01/status/2102203408086192181
Has used OpenClaw daily since January and has tested every serious alternative including Muse, Grok Bot and Hermes, and keeps coming back. His reason is not feature comparison, it is compounding: every workflow, skill, integration, memory and agent he adds makes the setup more capable, and it is built around his exact workflows with whatever mix of models he wants. If something is missing he builds it; if a better model appears he plugs it in. He says it reliably runs nearly every part of his business and personal life.
@Tails6198 [OpenClaw]
https://x.com/Tails6198/status/2102380297325027479
The counterweight to every OpenClaw success story, and worth publishing alongside them. A few hours of trying to use it produced: onboarding that is long, error prone and confusing, an extremely unpolished UI, outdated docs, and an agent that had been replying to all his WhatsApp texts saying his access is broken. Then it just breaks for no reason. His closing question is fair.
@theagenticdaily [OpenClaw]
https://x.com/theagenticdaily/status/2102213237865582632
Trend Micro found over 20,000 OpenClaw instances exposed on the open internet, many with plaintext API keys sitting in config files. The report also flags unsandboxed MCP servers and credential-stealing skills available on ClawHub. Read this next to the posts celebrating always-on personal agents: the same property that makes the setup powerful is what puts it on the open internet.
@geethika_isuru [Claude Code]
https://x.com/geethika_isuru/status/2102216946171441589
Day 2 of a public ten-day run at $2,000 revenue, and the useful part is the failure and the correction in the same post. Reddit accounts got banned, probably an IP ban too. A new account is at 300+ karma and warming up. Then the realization that manual posting was burning his time, so he is now automating the scheduling of his product output through Claude Code. Still $0 of $2,000.
@redsandlions [Claude Code]
https://x.com/redsandlions/status/2102348005269791109
Non-coding use case worth more than most of the coding ones. Fed Udemy practice questions into Claude Code and had it run drills, explain every wrong answer, manage progress and analyze his weak points. He says this got him through to the AWS Associate certification. The whole tutoring loop is a file of questions plus an agent that keeps score.
@Veniaminash [Claude Code]
https://x.com/Veniaminash/status/2102297965071040667
Honest cost post from someone building Polymarket bots. Works in Claude Code and ChatGPT in parallel on the most capable models available, and the screenshots do not even include roughly $1,500 spent on GPT-5.6 Sol through the API over two days. The result of that $1,500: realizing the backtest design was ineffective and all the work had to be thrown away. He is asking the room what workflow people actually use, because he can feel something is off with his process.
@swiftcomposer [Claude Code]
https://x.com/swiftcomposer/status/2102512243044909332
Built a motion-graphics workflow on Claude Code plus Design, and the interesting constraint is that he had Claude derive the design system from his existing brand codebase rather than describing it. Claude only generates an HTML version, so rendering out to video needed a skill he wrote himself. The output is going into a video on App Store conversion using data from an AppTweak study.
@ThomasBurkhartB [Claude Code]
https://x.com/ThomasBurkhartB/status/2102231472803369266
Answers a challenge about never hitting usage limits with his actual setup, and it is deliberately unfancy: two Claude Code sessions, one on a mobile app and one on the backend. Subagents on Sonnet, reviewers on Opus, coordinator on Fable or Opus. The model-per-role split is the whole trick.
@jimmyyangrz [Claude Code]
https://x.com/jimmyyangrz/status/2102358908463702293
Live demo of LUCI, which runs quietly in the background and sees and hears everything on your computer, then exposes that history over MCP so Claude Code, Codex, Cursor or any agent can query it directly. This is the same shape as the memory tools but sourced from the machine rather than from the agent own transcript, which means the context it can supply includes things the agent was never told.
@NFTCPS [Claude Code]
https://x.com/NFTCPS/status/2102301783829975285
Free open-source video editing tool for Claude Code called video-use, and the design choice is the interesting part. You drop raw footage in a folder, say cut this into a publishable clip, and it removes filler and pauses, color grades, adds subtitles and animation, and hands back a final.mp4 with no timeline and no manual work. It never actually watches the video: it transcribes the audio and cuts on word-level timestamps, which is what makes it cheap enough to run.
@paul010318 [OpenClaw]
https://x.com/paul010318/status/2102186839776129368
Reading the Designer-RSI work gave him the words for his own OpenClaw pain: the biggest problem in his workflow is that he accumulates piles of logs and then hits the same class of error again next time. Designer-RSI does not touch model weights, it adds or revises operating manuals from real tasks, and replays for verification before each update so fixing one thing does not break an old capability. His takeaway is that memory is not saving conversations, it is rewriting success and failure traces into an SOP the agent will actually call next time, with regression tests attached. Stop asking how much the agent remembers and check whether it changed the next run.
@chhddavid [Claude Code]
https://x.com/chhddavid/status/2102530668412674336
One line that captures where the ambition currently sits: Claude Code with Opus 5.5 can scan a whole website, build it as a mobile app, submit it to the iOS App Store and maintain it, with no human in the loop. Posted as disbelief rather than as a claim, which is the right register for it.
@dasepmochly [Claude Code]
https://x.com/dasepmochly/status/2102274320307548278
oh-my-claudecode at 39.3k stars, and the framing is about what single-session workflows actually cost: context limits hit fast, tokens bleed on simple tasks, and concurrent architectural changes across worktrees are painful. It spawns coordinated tmux workers across Codex, Gemini, Antigravity and Claude in isolated git worktrees, routes subtasks through a model-agent compatibility matrix with premium, balanced and budget presets, extracts reusable skills from your active sessions, and ships token telemetry with webhooks to Discord, Slack and Telegram.
@sitinme [Claude Code]
https://x.com/sitinme/status/2102218993625116870
The most useful thing written about the 292-skill ECC install is the part about hooks. He notes the project classifies hooks, MCP servers and project instructions together as executable configuration: hooks run shell, MCP may hold credentials, project instructions enter model context, and none of the three can be copied around like an ordinary config file. He approves of the installer behaviour where, if the install would land a hook runtime and you have not explicitly passed --enable-hooks or --no-hooks, it prints what hooks can do and then stops without writing anything. One trap worth recording separately: Claude Code 2.1 onward auto-loads hook config from plugins, so copying it into your own settings.json fires everything twice.
@al3rez [OpenClaw]
https://x.com/al3rez/status/2102261175908208649
The honest counterpoint to the whole self-hosted agent thesis, from someone who clearly knows the tooling. You can clone OpenClaw or Hermes, wrap it in iMessage or WhatsApp, and call it a billion-dollar idea, but a tool can be incredibly powerful and still go unused if people cannot fold it into their day. He uses Instinct daily precisely because he does not have to set anything up, keep it running, configure it or maintain it. His conclusion: setup keeps getting easier and a huge share of people still do not want to deal with any of it.
@maximilien912 [Claude Code]
https://x.com/maximilien912/status/2102261888377848043
A small but telling workaround from the usage-limit war: claude-swap lets you switch easily between two Claude accounts, which keeps your code quality constant instead of forcing a drop to a weaker model when one account runs dry. The alternative he is weighing is pairing a Codex subscription with codex-plugin-cc to run Codex inside Claude Code.
🗣 User Voice
User Voice
Usage limits have become an architecture constraint, not a billing detail. People are burning weekly quotas in two days, bouncing between tools and resetting context mid-flow, and the workarounds are now structural: per-role model assignment, account swapping, proxy-level accounting. @agentnativedev and @maximilien912 both describe this as something you design around rather than complain about.
The defaults are costing people money silently. Prompt suggestions on by default, a full skills list re-read every turn, session recap running whether you use it or not. Every one of these was discovered by an individual measuring their own logs, not documented anywhere. @iykshani and @ziyacivan both ended on the same implicit question: why is the expensive thing the default.
Nobody trusts an agent's own report of completion, and the fixes are getting concrete. A browser that has to agree before the run can stop, an A/B harness that makes a skill prove itself, a reviewer model that never sees how the code was written. @abhinavpangaria and @AbuZ8Studios are building the same thing from two directions.
Context does not survive leaving the tool, and that is now the top cross-agent complaint. Quit Claude Code halfway, open Codex, re-explain the architecture. @stas_sorokin_ actually measured it: a 3KB handoff note passed 7 of 7 checks, the word continue passed 5 of 7.
Permissions are still advisory when people think they are enforced. @AIJonHu audited his own setup and found a CLAUDE.md full of red lines, a settings.json that only blocked one spelling of delete, and no pre-execution hook at all. @Putriyolanditha's case is what that looks like when it goes wrong: a vague prompt, an unread contract, a signature PNG, and an email about to send.
Usage limits have become an architecture constraint, not a billing detail. People are burning weekly quotas in two days, bouncing between tools and resetting context mid-flow, and the workarounds are now structural: per-role model assignment, account swapping, proxy-level accounting. @agentnativedev and @maximilien912 both describe this as something you design around rather than complain about.
The defaults are costing people money silently. Prompt suggestions on by default, a full skills list re-read every turn, session recap running whether you use it or not. Every one of these was discovered by an individual measuring their own logs, not documented anywhere. @iykshani and @ziyacivan both ended on the same implicit question: why is the expensive thing the default.
Nobody trusts an agent's own report of completion, and the fixes are getting concrete. A browser that has to agree before the run can stop, an A/B harness that makes a skill prove itself, a reviewer model that never sees how the code was written. @abhinavpangaria and @AbuZ8Studios are building the same thing from two directions.
Context does not survive leaving the tool, and that is now the top cross-agent complaint. Quit Claude Code halfway, open Codex, re-explain the architecture. @stas_sorokin_ actually measured it: a 3KB handoff note passed 7 of 7 checks, the word continue passed 5 of 7.
Permissions are still advisory when people think they are enforced. @AIJonHu audited his own setup and found a CLAUDE.md full of red lines, a settings.json that only blocked one spelling of delete, and no pre-execution hook at all. @Putriyolanditha's case is what that looks like when it goes wrong: a vague prompt, an unread contract, a signature PNG, and an email about to send.
📡 Eco Products Radar
Eco Products Radar
Codex — the constant comparison point and increasingly the other half of a pair rather than a competitor, whether as reviewer, coordinator or worker.
DigitalOcean Managed Agents — cloud runtime for Claude Code and Codex, pauses on idle, resumes in ~300ms, Firecracker microVMs, credentials brokered outside the sandbox.
OpenClaw — still the reference implementation for self-hosted personal agents, and now also the reference for what happens when 20,000 of them face the open internet.
Hermes — paired with OpenClaw in nearly every overnight-agent setup mentioned.
Muse — Meta's consumer packaging of the same idea, and the reason half the OpenClaw conversation was about distribution rather than capability.
Jev — the decision-model layer showing up inside Claude Code for skill selection, context compaction and model routing.
MCP — the connective tissue in almost every workflow here: Discord, Search Console, Xero, Blender, flight sims, ad platforms.
Claude Code Skills — the unit of reuse everyone converged on, along with the new problem that a long skills list is a per-turn tax.
Cursor — still the tool people switch into when they want to stay in the diff and steer.
Codex — the constant comparison point and increasingly the other half of a pair rather than a competitor, whether as reviewer, coordinator or worker.
DigitalOcean Managed Agents — cloud runtime for Claude Code and Codex, pauses on idle, resumes in ~300ms, Firecracker microVMs, credentials brokered outside the sandbox.
OpenClaw — still the reference implementation for self-hosted personal agents, and now also the reference for what happens when 20,000 of them face the open internet.
Hermes — paired with OpenClaw in nearly every overnight-agent setup mentioned.
Muse — Meta's consumer packaging of the same idea, and the reason half the OpenClaw conversation was about distribution rather than capability.
Jev — the decision-model layer showing up inside Claude Code for skill selection, context compaction and model routing.
MCP — the connective tissue in almost every workflow here: Discord, Search Console, Xero, Blender, flight sims, ad platforms.
Claude Code Skills — the unit of reuse everyone converged on, along with the new problem that a long skills list is a per-turn tax.
Cursor — still the tool people switch into when they want to stay in the diff and steer.
Comments