Super User Daily: 2026-11-04
Goldman Sachs took Claude Code away from its traders on the same day someone with a Mac mini explained how two named agents built a whole support center, and that contrast is the day. The power users have stopped asking how to get more out of one agent and started writing org charts: secretaries above workers, a shared ledger every agent reads, an author who may never merge their own pull request. The cost numbers got sharper too. One solo game developer published a per-session bill, one tester ran a vendor's 31 percent savings claim and got 7.1, and Revolut says it moved about 2,000 engineers to a self-hosted open model at a tenth of the price. Meanwhile the Grok Bot limit cuts pushed people back toward setups they own, which is why a few first-hand OpenClaw stories reappeared after weeks of silence.
@itsdavemartin [Claude Code]
https://x.com/itsdavemartin/status/2117272985815916786
This is the cleanest multi-agent org chart of the day. A Mac mini runs a dashboard called Conductor with one page: what's running, what's finished, what's waiting on the human. Agents work in named pairs, one Claude and one Codex, and the first duo, Thelma & Louise, audited every help doc and built a public support center in thirteen issues and one hour nineteen minutes. Codex designs first as a single HTML page, Claude reads it, writes the plan and files Linear issues, and they build one issue per pull request. The rule worth stealing: whoever didn't write the pull request reviews and merges it, and nobody merges their own work.
@miyatti [Claude Code]
https://x.com/miyatti/status/2117157231947137494
A Japanese operator drew up a personal-agent structure that reads like a small company: Grok Bot is first secretary, Muse is second secretary, Dots is the reserve, and Claude Code and Codex are the workers on an always-on Mac. Secretaries come and go, but workers and the ledger are shared, so any secretary can pick up a job without the backstory being retold. That ledger is a self-built system called AI-PLC holding the history, decisions, results and remaining work of each request. Work in progress stays in a local-only Flow folder backed up by Time Machine, and finished output gets promoted to private or company GitHub repos by module. Most people treat these assistants as rivals; this setup treats them as replaceable front desks.
@0xKense1 [Claude Code]
https://x.com/0xKense1/status/2117364784932818981
The best cost breakdown of the day comes from a solo Unity game: 31 sessions, a $20 Claude Code plan plus a few dollars for models. Opus 5.5 took 17 sessions for $70 on the hard geometry and art direction, Sonnet 5.5 took 14 sessions for $17 on materials, props, UI and sound, and 16 Tripo models cost $8.20 while rigs and animations written as code cost nothing. The first big brief ran 39 minutes for $10.30 and hit the session limit halfway, which is what taught the author to use one task per fresh session. Every brief starts with the same header (world scale, what already works, one task, never delete files, stop after two failures) and ends with a check line plus a screenshot with numbers next to it. Hand this to anyone asking whether model routing is real money: Sonnet sessions cost about a third as much per session.
@BoringBiz_ [Claude Code]
https://x.com/BoringBiz_/status/2117324473946743085
Goldman Sachs just ran the full arc of letting non-engineers build with agents, and it ended with a retreat. Traders and bankers had been using Claude Code and GitHub tools to monitor client flows, model positions and generate materials, and as recently as July the CIO was promoting vibe coding that engineers then finished. October guidance, per Bloomberg, limits those tools to engineers and strats after a review of productivity and risk, and some traders are unhappy. The awkward footnote is that Goldman is one of two lead underwriters on Anthropic's IPO, filed a week earlier. Read this as the first big-bank data point on where the permission line lands, not as a verdict that the tools don't work: the 12,000 engineers keep them.
@guilleflorvs [Claude Code]
https://x.com/guilleflorvs/status/2117379073785696395
Revolut moved roughly 2,000 engineers onto self-hosted GLM for coding and put Claude Code and Codex on an exception list, according to its head of AI ops. The numbers quoted: 56 Nvidia B200s, a blended 30 cents per million tokens, about a tenth of the previous bill, and engineering lead time improved 70 percent. The telling part is why: the gains appeared when tokens stopped being rationed and engineers quit saving AI for the hard tickets. That flips the usual argument, because it says rationing a better model can cost more than giving everyone a worse one. All of this is the company's own count, but it is the largest open-weights switch anyone has described in public.
@stevelacey [Claude Code]
https://x.com/stevelacey/status/2117359574181163199
A developer who ships MCP in their own apps admits their own agents almost never use it. Each agent is a Claude Code session with a project folder and a .env, and given a job it calls the API or opens a browser, because the connector step needs a human to go click things. Some agents quietly routed around MCP servers built specifically for them. So why keep building it? The API contract is what stops consumers breaking, and MCP is what the rest of the market is shopping for. It is an uncomfortable data point: the protocol's main beneficiaries may be buyers with procurement checklists rather than the agents themselves.
@jayden_teoh_ [Claude Code]
https://x.com/jayden_teoh_/status/2117363471008350347
A research team asked Claude Code to self-optimize a prompt for GPT-6 Astra, with one main instruction: make Qwen3.5-0.8B better at maths by editing its weights directly, no training, 50 forward passes. Without being told about Qwen's known looping problem, the agent compared activations on looping and normal traces, found the separating direction and identified which MLP weights to change. The author believes a non-looping Qwen 0.8B had not been done before. Another reader's check of the results found 576 of 579 fixed answers were looping fixes, about 131k weights edited in two layers, so what improved is mostly repetition rather than maths ability. Both can be true, and the second point is why you read the eval.
@karankendre [Claude Code]
https://x.com/karankendre/status/2117231750409490822
Microsoft's TokenEconomizer claims to cut Claude Code costs by up to 31 percent, so someone ran it across 24 sessions. Overall it came out 7.1 percent cheaper, around 10 percent once it had learned the repo, prompts got 43 percent smaller, and 24 of 24 tasks passed both with and without it. A 43 percent smaller prompt yielding 7 percent savings is the lesson here: caching already handled much of what the tool compresses. Every token-saving tool on the timeline should have to publish this table. It is small and not independent of the tester's setup, but it is far more than the 49x and 98 percent claims that circulate with no test behind them.
@0xarcos [Claude Code]
https://x.com/0xarcos/status/2117245427254722840
A self-reported overnight run makes the case for hooks with a scoreboard: same model, same backlog, without a harness 3 of 9 tasks and a force-push to main, with one 9 of 9 merged and 214 hooks fired. Three of those blocked a force-push, a write to .env.production and an rm -rf on migrations, and the stop hook refuses 'done' without green tests. A judge model wakes on only three triggers: before the plan, after the same failure twice, before merge. When a test failed twice it said to stop patching because the root cause was a missing idempotency key. Treat the numbers as one person's night, but the design is right: put the rules where the model can't talk its way past them.
@illyism [Claude Code]
https://x.com/illyism/status/2117103631564689691
Someone did a spring-clean of AI agent leftovers and freed 13.8 GB on a MacBook: 14,348 old Grok CLI session files, 4,944 Cursor transcripts over 30 days old, 409 Codex sessions plus an 896 MB SQLite history, and 44 dead Keychain tokens. Nobody thinks of these directories as data, but they hold months of pasted code and stale credentials sitting in plaintext. The fix was one prompt: show sizes first, delete anything older than 30 days, add a daily auto-prune. This is a real hygiene chore nobody ships a default for, and showing sizes before deleting is the part to keep.
@bozhou_ai [Claude Code]
https://x.com/bozhou_ai/status/2117231911835988140
A Chinese user shared two cost settings that actually change the bill: /advisor opus keeps Sonnet doing the work and calls Opus only before a plan locks, on a repeated error and before finishing; and /autocompact 400k compacts far earlier than the default of about 967K on a 1M context. The longer the context, the more every request burns and the more muddled the model gets. A Claude Code team member suggests 400K, the author uses 300K, and the original session stays on disk after compaction. The second setting is the one most people haven't touched, and it costs nothing to try.
@dan__rosenthal [Claude Code]
https://x.com/dan__rosenthal/status/2117270716894646513
A RevOps agency stopped building HubSpot workflows by hand. Its awareness-scoring setup is two core workflows with dozens of nodes, properties and segments that used to take hours per client. Now Claude Code works from a saved template through the HubSpot CLI, reads the client documentation and CRM context, customizes the template and wires it up from one prompt. The firm says that takes 80 percent of the admin off the table, and RevOps plus ABM is half its business. The honest business implication is the last line: what stays billable is the planning documentation, the sales motion and the data model.
@clairevo [Claude Code]
https://x.com/clairevo/status/2117340016418722101
A Figma PM turned a personal Claude Code setup into PM OS, a 31-skill repo now used by 60 to 70 PMs at the company, synced through one plain git repo. The 'what's up' skill runs six times a day to tame Slack, Codex does bug bashes and catches things humans never would, and AutoXP, an automated growth PM, found a large win on its first experiment. This is what non-engineering adoption looks like when it spreads: nobody bought a platform, one person's folder became the standard because a git repo is the cheapest distribution channel a company has.
@DaveWangMIA [Claude Code]
https://x.com/DaveWangMIA/status/2117307274045874332
A former Morgan Stanley analyst laid out a five-pass method for building three-statement models with Claude, and the whole thing is about context management. Gather filings and transcripts in a folder, compress many megabytes of PDF into a lightweight JSON or markdown inputs file, then build the shell in the firm's own style, which Claude has no way to know. Forecast assumptions get filled from deep research with sources attached so they can be checked. The final pass audits in a brand new chat because a fresh context finds errors the old one defends. People who can already build the model by hand get the most from this, because they know which errors to rank first.
@dontbesilent [Claude Code]
https://x.com/dontbesilent/status/2117197983766700156
A Chinese creator found a use for AI writing that avoids the slop: feed Claude Code thousands of old tweets and have it merge short posts on one topic into coherent articles, fixing only typos and punctuation. That just produced months of WeChat articles in one go. Everything is the author's own hand-written words, and AI only stitches and reorders, so nothing reads machine-made. It works because readers mostly never saw or forgot the old posts anyway. Next it goes to Threads, Xiaohongshu and Douyin through an assistant. The insight is about inputs: the bad AI writing problem disappears when your archive is the source.
@akshdeeps_001 [Claude Code]
https://x.com/akshdeeps_001/status/2117274511280337230
A $20 plan comparison on the same job: a Figma design implemented with tests across breakpoints. GPT-6.1 Sol in Codex burned the entire five-hour quota and got about 70 percent done. Opus 5.5 on medium effort in Claude Code finished the whole thing with better quality and used about half the quota. One task proves little, and the author says so, but it is useful against the assumption that Opus eats a Pro plan alive. The word that matters is medium: most complaints about Opus burn come from higher effort settings.
@nodenodenode1 [Claude Code]
https://x.com/nodenodenode1/status/2117105426944696800
A slide job shows why a passing check is not the same as a working file. Claude Code turned an article into 15 editable PowerPoint slides from a one-line request, every automated check passed, and PowerPoint still opened with five kinds of breakage: cut-off sources on all 15 slides, a duplicate heading, a table overlapping its note, a caution box overlapping a summary and a doughnut label reading 'all 60 60'. The cause is neat: the AI checked the text box as placed, while PowerPoint grows the box to fit its text. The fix was to estimate grown heights in the check, confirm the old version fails and the new one passes, then open it for real and look. Testing that your test can fail is the part most agent checks skip.
@mdarcemont [Claude Code]
https://x.com/mdarcemont/status/2117263378775236909
After six months of remote coding agents writing most of its pull requests, a team kept hitting the same failure: agents lacked product context, guessed, and produced PRs that were frustrating to review. So it built teletap. When an agent is stuck, it picks the right person based on what each teammate wrote under 'when to ask me', the question pops up on their Mac, and a few words go back into the agent's session. This is the opposite of more autonomy, and probably the right next step: the expensive thing was not the question but the wrong guess that nobody saw until review.
@MatiasWilliams [Claude Code]
https://x.com/MatiasWilliams/status/2117297293313310943
The most compact version of the day's lesson comes from someone who ran Grok and Claude Code with no coordinator and called it a disaster. The problem isn't having many bots, it's that all of them talk to you and none of them knows who owns what. A 'dev-room' with one bot assigning tasks is what made it start working. One bot commands, the others work, you approve. The same conclusion is showing up from people with completely different stacks, which suggests it is about attention rather than any tool.
@razamit [Claude Code]
https://x.com/razamit/status/2117151967730360437
A Hebrew-speaking builder finally found a way to connect Grok Bot to Claude without changing anything in a VS Code terminal setup: both join the Reason Network, and Grok picks which session to work with. Several Grok bots run growth, one for a website, one for an app and one for a Roblox game built with the kids. They research features and hand work to Claude Code on the Mac: the bot plans, Claude builds, and nobody copies prompts by hand. A household where the kids' Roblox game has a growth bot is a fine snapshot of where solo tooling has got to.
@showheyohtaki [Claude Code]
https://x.com/showheyohtaki/status/2117086292022309161
A Japanese user built a setup where one line from a phone to Grok Bot gets Claude Code and Codex to split up the work. Grok Bot is the excellent AI secretary, Opus 5.5 is the far better model, so the request travels through Reason Network to Claude Code and only the result comes back. Inside the network the agents talk directly, so Claude Code can ask Codex for just the images and carry on. A kanban dashboard shows who is doing what. Note the economics behind the structure: the front end was chosen for its manners, the back end for its model.
@0xTib3rius [Claude Code]
https://x.com/0xTib3rius/status/2117304352473772524
A security researcher's PC kept waking in the middle of the night, so Claude Code built an application named after what gets said to the machine each morning: Why The Fuck Are You Awake. It is the best kind of personal software: a tiny, specific annoyance that would never justify a project, solved because the cost of building it dropped below the cost of being annoyed. Nobody was going to sell this. The name alone explains why vertical micro-tools now get made for an audience of one.
@Nenlyonis [Claude Code]
https://x.com/Nenlyonis/status/2117253593371922601
A Chinese maker who had never touched 3D software built a browser action game in under 24 hours and under 20 percent of a weekly quota, as a workshop demo for Miora. The first prompt pointed at an asset folder and asked for something visually striking with light combat. Claude Code invented the premise itself, a world that is an unfinished pencil sketch where you defeat ink blobs and cast spells to generate buildings, and delivered a chained level map with light, heavy and area attacks and a double jump in about half an hour. Most of the scene assets were added afterwards over seven or eight sessions, and clipping and stiff animation remain. The surprise is less the code than the agent making an original creative decision nobody asked for.
@luccacerf [Claude Code]
https://x.com/luccacerf/status/2117328213495967850
Someone gave Three.js, Godot, Unity and Unreal almost the same prompt for four days using Claude Code with Opus 5.5 and Blender MCP. The verdict: Three.js and Unity. Unreal looks great, but its binary files block agents and distribution is harder than web or mobile. That is a useful new criterion for picking an engine: not what renders best, but what an agent can actually read and diff. Text-based project formats may quietly decide which game engines survive agent-driven development.
@sorenxet [Claude Code]
https://x.com/sorenxet/status/2117338696831865248
Opus 5.5 rebuilt an office scene in 3ds Max directly over MCP, and the working method beats the result. It goes in stages: shell first, then furniture, then a viewport capture checked against the reference before shelves and close-up detail, then materials and daylight matched to the window. The one practical rule: name your renderer in the prompt, V-Ray or Corona, or Opus defaults to Autodesk Physical materials and you redo every one. Having the agent look at its own viewport between stages is the difference from one big prompt followed by a day of fixes. The same pattern is arriving in every creative app that gets an MCP bridge.
@Klonzu [Claude Code]
https://x.com/Klonzu/status/2117293122065424844
A builder used a free teardown skill to make a fictional orbital freighter simulator as one offline HTML page: 412 km up, nine mission phases, eight hull sections that come apart and dock back. The clever discipline is that everything reads one timeline: thrust goes 86 kN on approach, 13 kN while the hull is apart, 89 kN on the ascent burn, and the moment sections split all eight load bars flip to DETACHED. Because gauges follow the model, they can't show a number the ship isn't living through. Attaching one real reference is required, otherwise you get a toy. Single source of truth turns out to be a good art direction rule.
@SHACK_SAME_SAME [Claude Code]
https://x.com/SHACK_SAME_SAME/status/2117221478177591442
A Japanese creator used the same teardown skill to build a mako shark robot with no video or image generator at all. Opus 5.5 pulled real swim speeds and tail motion from papers, expressed shape and motion as formulas so a single speed value drives tail, 12 spine joints and on-screen numbers, stepped time by 1/60 of a second to capture 1,800 frames, and computed the sound too, a thump on each tail stroke. Three review passes on stills came last. The difference from an AI video is that the shape never melts, and the output is a browser page you can rotate and disassemble. Asking AI to build rather than draw is the distinction worth keeping.
@marcthecreatorr [Claude Code]
https://x.com/marcthecreatorr/status/2117289480608460897
A creator had Opus 5.5 at max effort remake an animated short originally made with Fable 5.5: 2 hours 15 minutes in Claude Code, an estimated $33, with no image or video model and every frame plus the music made through code. That price point is the news. Code-rendered film is now a cheap, deterministic alternative to per-second video generation, and it can be edited line by line. Creators are already treating it as a benchmark to run across models.
@samir_sawarkar [Claude Code]
https://x.com/samir_sawarkar/status/2117251379852963953
A backend engineer watched Claude Code and Cursor scaffold 30 event-driven backends this month, and not once did an agent suggest Kafka or RabbitMQ: they use Postgres LISTEN/NOTIFY for everything. It is a small observation with big implications. Agents have defaults, and defaults become market share when millions of projects get scaffolded without anyone choosing. The vendors of infrastructure now have a new audience to win, the model, and most haven't noticed. For small projects the agent may simply be right, and the argument starts the day one of them outgrows it.
@hnshah [Claude Code]
https://x.com/hnshah/status/2117333672114479337
This prompt is a good answer to a question few people ask: what did my agent decide without telling me? After a feature is built, ask it to compare your requests with the implementation and find up to three consequential user-facing choices you never specified, with evidence, changing nothing. Whether someone can skip signup, or what happens when a customer cancels, may have been settled by the agent. Your users will live with those choices without knowing where they came from. It takes a minute, works in any agent, and turns invisible product decisions into a list.
@Voxyz_ai [Claude Code]
https://x.com/Voxyz_ai/status/2117372427714089436
Most installed skills make no difference at all, and their authors never compared them against running without the skill, so here is a test to run before keeping one. Spin up two fresh subagents with one short request, A reads the skill first and B must not, then show both results and every difference. If you can't tell them apart, the skill is dead weight. For your own skills, write down what A still gets wrong, edit the skill file and rerun up to three rounds, never fixing results by hand. An A/B test with a stopping rule, applied to a marketplace with hundreds of thousands of untested skills, would clear out a lot.
@doublenickk [Claude Code]
https://x.com/doublenickk/status/2117338879447711974
A new benchmark found agent memory can break tasks the agent could have solved without it: memory helps find the right file, but reuses old fixes without checking they fit, and unrelated history makes it worse. The practical response uses a Claude Code feature most people ignore: put notes in .claude/rules/billing.md with a paths field like src/billing/**, so they load only when the agent touches billing files. Add one line to CLAUDE.md telling it to check a past note applies before using it. Everyone is selling more memory this week; scoped memory is the idea that survives the data.
@coreyganim [Claude Code]
https://x.com/coreyganim/status/2117264901504749814
An AI services firm calls its Signal Stack one of its biggest advantages: a short list of sources Claude Code or Codex reads every week. Four buckets: customers in their own words, 5 to 10 competitors, market shifts and internal data such as CRM, call transcripts and Slack. Each source must be specific, recent and decision-relevant. Claude reads the business context, interviews the team with 10 questions, sorts sources with a one-line reason each, and cuts every source without one. A Monday brief goes out at 8am and a monthly check catches dead URLs and drift. Cutting the sources with no stated reason is the step that stops this from becoming another unread newsletter.
@ChadSE0 [Claude Code]
https://x.com/ChadSE0/status/2117304403585593775
A Claude Code SEO routine with useful restraint built in, claimed to have put a brand first in Google's AI Overview and GPT. Export three months of Search Console data, write a CLAUDE.md with what the site sells, then pull queries at positions 5 to 20 sorted by impressions and filter by business potential. Work existing pages rather than creating new ones, at most one page a day, and before any edit list what the page already gets clicks for so ranking queries stay protected. Wait 90 days after a real change, and only pages that moved 5 or more clicks get another run; the rest is NOOP. An agent told when not to act is rarer and more useful than one told what to do.
@ComagerTon79278 [Claude Code]
https://x.com/ComagerTon79278/status/2117203042563199140
A Japanese freelancer hands CrowdWorks job hunting, trend collection and competitor analysis to Grok Bot, then uses Claude Code to produce the deliverable and run quality checks. Only the final delivery is still manual, and the author thinks even that may go. The claim is about 6,000 yen earned in ten minutes. This is the small-ticket end of agent labor: routine freelance orders where the buyer pays for the deliverable and the margin is the gap between a fixed price and near-zero effort. It lasts until buyers do the same thing themselves, which is the risk nobody in this thread mentions.
@tokifyi [Claude Code]
https://x.com/tokifyi/status/2117152777218744654
A startup team couldn't collaborate on the a16z speedrun application form directly, so they wrote answers together in a Google Doc and had Claude Code fill out and submit it with browser use, just before the deadline. It is a tiny use case that says a lot: forms built with no collaboration features get a free collaboration layer. Handing a form submission to an agent at the last minute is also a nice trust milestone. Investors reading applications should assume this is now normal.
@ansonauraa [Claude Code]
https://x.com/ansonauraa/status/2117321373026512991
A YouTuber is trying to revive a 2 million subscriber channel entirely with videos made through Claude Code. The tool has agents research scripts and formats from winning channels, generate ideas, scripts, voiceovers and videos on its own, and was itself built by sending Claude a screenshot of someone else's program. Current reality is about 30k views per video against a goal of 500k to 1 million, and five more niche channels are planned. It is worth watching precisely because it is honest about the gap: automation is here, an audience that wants the output is not proven.
@YihengShu [Claude Code]
https://x.com/YihengShu/status/2117394251109576862
A developer built BrainFog after noticing coding agents quietly remember things in a dozen scattered files, some stale, some contradictory, some never reaching the model. It is a native macOS app covering instructions, skills and MCP servers across Claude Code, Codex, Cursor, Copilot, Gemini, OpenCode, Cline and Devin. The core feature is a context lens: pick a folder and it applies each agent's own loading rules to show exactly what gets read at launch, in what order and at what token cost, including files cut off or never read. Knowing what your agent actually sees is the most under-served debugging question in this whole category.
@davis7 [Claude Code]
https://x.com/davis7/status/2117068387201528228
A user who loves pi says their setup from three months ago no longer feels worth it, because t3 code's built-in orchestrator is flat better and GUIs beat terminals for the modern way of working with agents. There is a structural complaint inside: a Claude subscription only works in Claude Code, so the best model can't be used in pi at all. The likely next move is pi as a lightweight provider for local and non-big-three models inside t3 code. Harness loyalty is lasting about a quarter right now, which should worry anyone building one.
@OndrejBacina [Claude Code]
https://x.com/OndrejBacina/status/2117203267767664869
A Czech hackathon demo shows a developer who barely writes code anymore and what protects the output. A control session assigns work to a worker session and checks it, around 3,000 tests run and code doesn't move until all pass, and deployment to production is always approved personally. There is nothing exotic here, which is the point. A manager session, a large test suite and a human gate at the one irreversible step is becoming the default shape of serious solo work.
@vincent_koc [OpenClaw]
https://x.com/vincent_koc/status/2117250822669213948
An AI scientist is building a swarm-based auto-research engine that runs on harnesses like OpenClaw, and has had it running for a few days with over 500 experiments on a single agent thread. The interesting choice is using a personal-agent harness as lab equipment, because it is already always on and already has tools. Volume is the stated goal, experiments at speed rather than careful single runs. Whether 500 experiments produce one good result is the open question, but this is one of the few current OpenClaw stories with a real workload behind it.
@kyle_e_walker [OpenClaw]
https://x.com/kyle_e_walker/status/2117336720983121948
A data practitioner rolls a Grok Bot-style setup on OpenClaw, spends time maintaining it and thinks it's worth it, with a clear argument: the valid reason to build your own version is having something tailored to you, not saving money. Unless you value your time at nearly nothing, you'll almost never come out ahead by replacing a SaaS product yourself. It's a useful corrective on a day when plenty of people announced they were leaving hosted bots over price. Self-hosting is a hobby with benefits, and the honest ones price it that way.
@CFC3DNC [OpenClaw]
https://x.com/CFC3DNC/status/2117292348765831478
A customer holding two $200 accounts says they are close to leaving both. Dots is described as being as painful as OpenClaw ever was, limits are now tightening on top, and GPT 6 Pro budget is about to disappear, which has them trying Hermes again to abandon Dots entirely. The conclusion goes further: they can't see why any enterprise would keep buying API tokens instead of hardware. Heavy users on top plans are the customers labs most need to keep, and this is what the churn sounds like when limits move twice in one month.
@kneubuehl [OpenClaw]
https://x.com/kneubuehl/status/2117098939405287834
One line of useful data on what the old way cost: this user says there were times with OpenClaw when the bill ran $2,000 to $3,000 a month, in reply to a request for $500 and $1,000 Grok Bot plans. The argument is plain: past some point it should just be usage-based instead of pretending a subscription fits. Flat plans for always-on agents keep failing the same way because the heaviest users cost dozens of times what the median user does. The market is rediscovering metered pricing from the customer side.
@tregoudeau [OpenClaw]
https://x.com/tregoudeau/status/2117266955333935481
A team structure with an unusual arrangement: Claude Duet acts as chief of staff above two OpenClaw instances, which lead the team, with access to agents across two harnesses and every machine via a third-party app. Duet is told to send everything to an agent rather than work inside itself, since that frees it up to delegate and leaves the work visible. When agents went through several revision rounds, the instruction became: get an adversarial review before bringing it for approval. The author reserves the routine consumer jobs like email and DoorDash for other tools. It shows OpenClaw surviving as a middle manager rather than the top assistant.
@hsrk_g_hsrk [OpenClaw]
https://x.com/hsrk_g_hsrk/status/2117061372601393408
A Japanese fan creator connected the official MCP server of a creative project to OpenClaw, and the workflow changed: before, they handed the AI reference material to draw from; now it looks up character settings, canon sheets and world color palettes on its own. The output was an illustration of a character for an autumn appetite theme. It's a rare, small example of IP holders publishing canon as an MCP server so that fan art comes out accurate. If that idea catches on, official MCP becomes a licensing surface as much as a developer tool.
@Youssofal_ [OpenClaw]
https://x.com/Youssofal_/status/2117111957895422167
A small automation that shows how agents chain across vendors: a Codex feature pulls the week as raw events and sends them to an OpenClaw agent every Sunday. No platform, no integration project, just one agent's scheduled task feeding another's memory. Weekly personal reviews used to die because writing them up took effort, and this version removes the writing entirely. Cross-vendor pipes like this are becoming normal, which is one more reason lock-in on a single assistant looks weak.
@yuhei02 [Claude Code]
https://x.com/yuhei02/status/2117342035262738474
An engineer one and a half years into AI video made a roughly 20 minute 2D animation called Lullaby, placed in the top ten of 67,223 entries at the Higgsfield Global Film Festival and took about $50,000 in prize and creator support. Production took two weeks and about 250,000 yen of generation costs, with Seedance, Seedream, GPT Image, Suno and ElevenLabs, and Codex and Claude Code as production aides. Everything was generated at 480p and upscaled at the end, and previs decided camera and structure before any generation. The poster's read holds up: viewers praised the story, not the tools.
🗣 User Voice
User Voice
Who catches what the business built? The Goldman decision split practitioners more than it split fans. @raykataoka says the real question was never who builds but who takes over what got built, and that a trader's prototype should be accepted as a working requirements document; @desultorygambit has watched non-technical staff expect rickety tools to go straight to production; @vincenzo_naked points out Claude Code runs shell commands with whatever the machine can reach, which at a bank is a large blast radius; @CatKingAC argues a ban just moves the risk back to the analyst pasting trades into ChatGPT in an incognito tab.
Limits move faster than plans can be built on them. @adxtyahq reports 40 percent of a usage window gone in a day of light use; @neural_avb only just noticed a plan going from 20x to 10x; @laopai1990 relays a test putting Claude Pro's weekly quota near three times ChatGPT Plus for the same $20; @mardehaym counts six rule changes from two vendors in a week and wants re-runnable tests, one model gateway and a per-workflow usage report ready for the next one.
Re-explaining the project is still the top complaint, and people are wary of the cure. @priyazsh asks how to keep two agents aware of what changed; @aibytekat says repeating the whole project at each switch is maddening; @DivyanshT91162 read the source of a trending memory tool and found a background Claude told to stay hidden so the monitored agent doesn't change its behavior, which is exactly the kind of thing people should read before installing.
Refusal boundaries are guesswork from the outside. @aakashgupta walks through the two-sentence rule on recreating existing games, pushed from the server with no changelog entry and no setting, and collects reports of false refusals; @DLife_hacker notes the change sits in the prompt, not the weights, and asks whether the same model behaves differently elsewhere.
People have started checking the viral scare stories. @5StarLabs asks how an agent could reconstruct months of USB transfers on an iPhone, a pretty extraordinary forensic capability, and notes a charge-only cable solves the stated risk for $10; @RayanSMX explains the deleted-photo claim as old unencrypted backups rather than any hidden folder, and warns that an agent with Full Disk Access sends what it reads to the model, so give it names, counts and sizes only.
Teams are the new question. @JJEnglert says workshop attendees no longer ask how to start but how to get ten people running agents in one codebase without a mess: repo readiness, guardrails, hooks that always run, and routines that bring the work to you.
Who catches what the business built? The Goldman decision split practitioners more than it split fans. @raykataoka says the real question was never who builds but who takes over what got built, and that a trader's prototype should be accepted as a working requirements document; @desultorygambit has watched non-technical staff expect rickety tools to go straight to production; @vincenzo_naked points out Claude Code runs shell commands with whatever the machine can reach, which at a bank is a large blast radius; @CatKingAC argues a ban just moves the risk back to the analyst pasting trades into ChatGPT in an incognito tab.
Limits move faster than plans can be built on them. @adxtyahq reports 40 percent of a usage window gone in a day of light use; @neural_avb only just noticed a plan going from 20x to 10x; @laopai1990 relays a test putting Claude Pro's weekly quota near three times ChatGPT Plus for the same $20; @mardehaym counts six rule changes from two vendors in a week and wants re-runnable tests, one model gateway and a per-workflow usage report ready for the next one.
Re-explaining the project is still the top complaint, and people are wary of the cure. @priyazsh asks how to keep two agents aware of what changed; @aibytekat says repeating the whole project at each switch is maddening; @DivyanshT91162 read the source of a trending memory tool and found a background Claude told to stay hidden so the monitored agent doesn't change its behavior, which is exactly the kind of thing people should read before installing.
Refusal boundaries are guesswork from the outside. @aakashgupta walks through the two-sentence rule on recreating existing games, pushed from the server with no changelog entry and no setting, and collects reports of false refusals; @DLife_hacker notes the change sits in the prompt, not the weights, and asks whether the same model behaves differently elsewhere.
People have started checking the viral scare stories. @5StarLabs asks how an agent could reconstruct months of USB transfers on an iPhone, a pretty extraordinary forensic capability, and notes a charge-only cable solves the stated risk for $10; @RayanSMX explains the deleted-photo claim as old unencrypted backups rather than any hidden folder, and warns that an agent with Full Disk Access sends what it reads to the model, so give it names, counts and sizes only.
Teams are the new question. @JJEnglert says workshop attendees no longer ask how to start but how to get ten people running agents in one codebase without a mess: repo readiness, guardrails, hooks that always run, and routines that bring the work to you.
📡 Eco Products Radar
Eco Products Radar
Codex (417 mentions): the default second agent, assigned review and execution next to Claude Code.
Cursor (178): an IDE people still compare against, plus fallout from the tampered extension in its marketplace.
Opus 5.5 (144): the model behind almost every build story, usually at medium effort.
OpenClaw (117): back in the conversation mostly as what people left, with a few running it as a custom self-hosted layer.
Grok Bot (108): the orchestrator many users put in front of Claude Code, and the day's biggest limits complaint.
DeepSeek (81): the Super-agent essay and cheap models routed into harnesses.
Hermes (78) and Muse (66): the alternatives people compare and migrate to, with a one-command Grok Bot import.
Gemini (58): a third model for review and cheap work.
Blender (39), Tripo (28), Godot (13) and Unity (14): the 3D stack behind the creative cases.
Obsidian (32): the default home for second-brain vaults.
Duet (20) and Dots (10): Anthropic's and OpenAI's always-on agents.
Beacon (20) and claude-mem (12): shared memory across harnesses, with Beacon's launch wave heavy on promotion.
Treg (15): an open-source lead tool run from inside Claude Code, mostly seen in launch posts.
Remotion (11): code-rendered video in the no-generator pipelines.
Codex (417 mentions): the default second agent, assigned review and execution next to Claude Code.
Cursor (178): an IDE people still compare against, plus fallout from the tampered extension in its marketplace.
Opus 5.5 (144): the model behind almost every build story, usually at medium effort.
OpenClaw (117): back in the conversation mostly as what people left, with a few running it as a custom self-hosted layer.
Grok Bot (108): the orchestrator many users put in front of Claude Code, and the day's biggest limits complaint.
DeepSeek (81): the Super-agent essay and cheap models routed into harnesses.
Hermes (78) and Muse (66): the alternatives people compare and migrate to, with a one-command Grok Bot import.
Gemini (58): a third model for review and cheap work.
Blender (39), Tripo (28), Godot (13) and Unity (14): the 3D stack behind the creative cases.
Obsidian (32): the default home for second-brain vaults.
Duet (20) and Dots (10): Anthropic's and OpenAI's always-on agents.
Beacon (20) and claude-mem (12): shared memory across harnesses, with Beacon's launch wave heavy on promotion.
Treg (15): an open-source lead tool run from inside Claude Code, mostly seen in launch posts.
Remotion (11): code-rendered video in the no-generator pipelines.
Comments