Super User Daily: 2026-10-08
Tuesday's feed had two kinds of Claude Code user: the ones building teams and the ones auditing bills. On the team side, three separate posts described the same architecture with different jobs, Opus 5.5 as lead, a swarm of Sonnet 5.5 workers in their own git worktrees, and Fable 5.1 as a read-only skeptic that only speaks at three moments, applied to feature builds, competing-hypothesis debugging and a self-drawing project map. On the bill side, one cost audit found $710 a month hiding in late Sonnet-to-Opus escalations and cold cache rewrites across 4,812 calls, a Jev-based memory mod classified 87 turns for $0.0018, and a developer who burned a 20x Max plan in five days built a local approval bot because two agents could not approve each other's prompts. The non-coding work was unusually physical: a 10-minute Bruce McLaren documentary with archive footage, a 1989 DOS artillery game rebuilt with black holes and relativistic aiming, a Saudi tender-tracking lead engine, 200K dollars a month of ad spend run from a terminal by one person, a French bank replacing half its internal apps, and a sleep-data pipeline off a Fitbit. OpenClaw's best story was an agent that found its embedding API credits exhausted, inspected the machine, downloaded a local embedding model and finished the job on its own, while two other users gave up on a 2.0 install after a day of permission errors and were productive on Hermes in 15 minutes.
@eng_khairallah1 [Claude Code]
https://x.com/eng_khairallah1/status/2107580383357542646
eng_khairallah1 posted a full three-model team setup for Claude Code using the --agent flag. Opus 5.5 runs the main session at high effort as the architect, scoping work and validating every worktree before merge; Sonnet 5.5 teammates each take an isolated git worktree and implement at medium effort; Fable 5.1 sits on the team read-only as a dedicated adversary that only speaks at three moments: before a contract locks (does the frontend payload match the backend schema), when a test breaks twice (patching the bug or hiding the symptom), and before merge (what attack surface did everyone miss). Teammates message each other by name without routing through the lead, and the tools line locks the architect to spawning only its own team. The post frames the pattern as plan on high, delegate on medium, keep the adversary on call.
@thedelost [Claude Code]
https://x.com/thedelost/status/2107579690114310277
thedelost described a debugging team built on the competing-hypotheses pattern from Anthropic's own Claude Code docs. One agent finds a plausible cause and stops looking, so instead Opus 5.5 on high writes five hypotheses from plan mode and never digs itself, five Sonnet 5.5 investigators each take one theory read-only and try to kill the others, and a Fable 5.1 skeptic owns no theory and only interrupts when a theory claims proof (which log line shows it), when two theories agree (evidence or echo), and before the fix ships (does it explain every symptom). The findings doc is updated only with what survives. The whole thing starts from one plain-English prompt asking for five teammates to disprove each other like a scientific debate, with --teammate-mode auto for split panes.
@Voxyz_ai [Claude Code]
https://x.com/Voxyz_ai/status/2107455844992299272
Voxyz_ai shared a subagent that does nothing but draw project maps for overnight Opus 5.5 runs. The project-map agent is defined in ~/.claude/agents on opus at medium effort with user memory, preloads an installed design skill, reads code, git history and issues, and only writes to a .project-map folder that it adds to .gitignore. On first run it asks for dark or light and an accent colour and saves that to memory so later maps match. It runs in the background while the main session keeps coding on high, updates after every milestone, and the map shows four things: the parts the project breaks into, how far each has got, what is stuck or waiting, and what to do next, with the agent proceeding on that default if nobody decides.
@gippp69 [Claude Code]
https://x.com/gippp69/status/2107481859701555484
gippp69 ran a /cost-audit skill over the usage log of an agent loop that already looked optimised. Claude Code read 4,812 calls across 1,000 tasks, flagged late Opus escalations, cold-cache rewrites and effort changes, and then rewrote the router, handoff and session rules around those three leaks. The biggest was late escalation from Sonnet to Opus. After the fixes the same workload went from $2,530 to $1,820 a month, $710 saved with no model change. The point of the post is that Claude Code can audit the system it runs inside, not only write code for it.
@realKevinPuray [Claude Code]
https://x.com/realKevinPuray/status/2107283853882916873
realKevinPuray burned through a Claude 20x Max plan in five days using Fable 5.1 and Opus 5.5, versus a day and a half for a GPT 6 Astra allowance, and now rotates between Claude Code and Codex to keep both subscriptions fully used. The more interesting part is Sky, a local clicker and approval assistant controlled through Dots that is about to be open-sourced: Claude Code asks for approvals in the terminal, and their Codex plus Claude Code setup prevents the agents from approving each other's prompts, so Sky handles those interactions under explicit instructions while the person decides what gets approved. The post also retires Grok bots and Cursor and recommends adding Forgejo to the loop.
@biektive [Claude Code]
https://x.com/biektive/status/2107555318427447393
biektive described a Claude Code memory system that costs $0.0018 per 87 checks. A Claude Mod catches the end of every turn, then a tiny Jev classifier asks one question: is this a lasting preference or a one-off task. A line like always prefix branch names with sx/ scores 0.95 and goes to .claude/jev-memory.md; build me a Tetris game scores 0.03 and is skipped. The check runs after the turn so Claude never waits for it, and only a few saved lines enter the next session instead of the whole history. The architecture is four steps: Claude finishes, the mod catches the event, Jev classifies, code applies a 0.8 threshold.
@rewind02 [Claude Code]
https://x.com/rewind02/status/2107488247739732250
rewind02 laid out an eight-step workflow for building a game in Unreal Engine 5 with Opus 5.5 working inside the live editor. Start from the Third Person template so you can walk and jump from minute one, enable Unreal MCP and AllToolsets, install Epic's plugin in Claude Code and have Opus read the project before touching it, then one prompt builds a playable base level with a valley, a path, a town and three collectibles. Test the route with the default mannequin before any custom art, bring in a rigged character on the UE5 skeleton and let Opus wire walk, run and jump, then import assets and refine in small batches. The rule that saved the project: a successful tool call does not mean the level is right, so check the editor after every batch and never change terrain, lighting and character in one prompt.
@maxescu [Claude Code]
https://x.com/maxescu/status/2107428182370693460
maxescu let Claude Code run for a day on something it is not supposed to do: make films. The result is a 10-minute Bruce McLaren documentary with real archive footage and McLaren's own voice. A companion post lists the toolset: Opus 5.5 with film-production-playbook, seedance-2-5 and workflow-authoring skills; Higgsfield for Nano Banana 2, Seedance 2.5 and voice cloning; ElevenLabs for music; ffmpeg, Node canvas and a Python stack of numpy, scipy, librosa and pyloudnorm for local processing; and local Whisper, a phoneme model, a music detector and a SpeechBrain accent and speaker-verification model running as checks. Research sources were yt-dlp, Wikimedia Commons, DigitalNZ, the Internet Archive and Trove.
@jurlycat [Claude Code]
https://x.com/jurlycat/status/2107521243117433119
jurlycat reported someone rebuilding a 1989 DOS game with Claude Code and then adding black holes and time dilation. Gravity Wars is an artillery duel where shots bend past planets, stars and black holes, with a stated Schwarzschild orbital correction in the aiming physics. Almost all the code came from Claude Code across many sessions while the creator played, tested and chose what to build next, in plain JavaScript with no frameworks or npm dependencies. Before every commit, Node scripts check energy conservation, orbital precession and CPU aiming accuracy, Playwright checks visuals in Chrome and Firefox, and even the trailer was rendered from the game itself with Playwright and ffmpeg.
@Stefan_3D_AI [Claude Code]
https://x.com/Stefan_3D_AI/status/2107500485821510085
Stefan_3D_AI rebuilt F-Zero X, the N64 racer, in two days. The division of labour was explicit: the person played, Claude Code built, and their own generation workflows produced the art, animations and VFX. Then they lost hours racing it. The playable link is in the post, and the claim is that anyone can make something like this now.
@jurlycat [Claude Code]
https://x.com/jurlycat/status/2107373436569792582
jurlycat also relayed a GTA meets Mirror's Edge parkour game vibe-coded with a fully local model. GLM-5.3-Flash ran on two DGX Sparks with NVFP4 quantization and DFlash2 speculative decoding, with Claude Code as the coding harness. The builder reported about 1,500 tokens a second prefill and about 40 tokens a second decode at 100K context, debugged building collisions, then added flips, rolls and ledge grabs. The framing: local AI now has enough speed and context to build something playable and keep iterating.
@mhmazur [Claude Code]
https://x.com/mhmazur/status/2107459343218057324
mhmazur asked Claude Opus 5.5 to generate 500 examples of visualizations built with nothing but the HTML canvas element, and it did. None use Three.js, WebGL or any library; Claude Code wrote every one in vanilla JavaScript on a 2D canvas, from archival bubble-chamber film of particle collisions and a physically modelled throat that sings vowels to a garden spider spinning its web and a dial-up modem handshake. Each visualization ships with a prompt to paste into Claude Code or Codex to build your own version, and you can favourite the ones you like. Claude's own estimate is that half the gallery is classic demos, 35 to 40 percent is real science or math that rarely gets an interactive demo, and 10 to 15 percent is new. Opus plus an ElevenLabs voice also made the 60-second launch video.
@Abdullah_Ops1 [Claude Code]
https://x.com/Abdullah_Ops1/status/2107375953932378331
Abdullah_Ops1 built a sales engine around Saudi government procurement with Claude Code. The system pulls projects that have been awarded, identifies the winning company, enters it into the system and analyses it as a sales opportunity, then outputs a lead score, what you could sell them, and a ready-to-send outreach message. The post includes a recorded walkthrough and frames it as taking a slice of the cake from companies that just won public contracts.
@itsalexvacca [Claude Code]
https://x.com/itsalexvacca/status/2107549469655155046
itsalexvacca posted a full breakdown of how one person runs LinkedIn, Meta and Google ads from Claude Code: their head of ABM manages over 200K dollars a month of client ad spend from a terminal, a job that used to take a team of six, with 12 skills built in a set order. Step one connects the three platforms through Meta's and Google's official MCP servers, applies early for LinkedIn API access, writes a CLAUDE.md with ad accounts and naming rules, and gates every launch, bid, budget and pause behind a human yes. Step two starts with only two skills, spend-tracker (flags campaigns 20 percent off weekly target) and performance-auditor (week over week deltas), then creative-fatigue-analyzer, with no new spend in week one. Step three builds the account list from closed-lost deals, stalled deals and old MQLs, scores fit and timing separately, and uploads customers and competitors as an exclusion list before any prospecting goes live.
@virgilerietsch [Claude Code]
https://x.com/virgilerietsch/status/2107428036094099967
virgilerietsch needed Instagram leads for a client project and spent days testing scraping and lead tools, finding most of the cost was subscriptions rather than data. Treg, an open-source alternative to Clay that runs straight in Claude Code or Codex, can search Instagram creators, pull public contact info and enrich them behind one key: 100 leads cost $0.58 on Treg against $3.77 on Clay, and it is 25x faster. The practical point is that their agents already live in Claude Code, so lead finding happens there too without paying for another seat.
@ChicagoBoyFR [Claude Code]
https://x.com/ChicagoBoyFR/status/2107411572624646290
ChicagoBoyFR relayed a morning conversation with the CEO of a large French financial institution. The bank has begun replacing more than half of the applications used internally with solutions developed using AI code generators, typically Claude Code, and expects licence-cost savings in the tens of millions from 2027. The rest of the conversation was about France's fiscal situation and is outside this digest.
@mardehaym [Claude Code]
https://x.com/mardehaym/status/2107431499704258639
mardehaym described a PE-backed US healthcare data company where every engineering team had invented its own way to use AI with no shared controls over spend or model access. The engagement started by teaching one practice (write the spec, define expected behaviour, test, review, make clear where a human decides), then configured Claude Code around the organisation's standards and packaged it as a plugin with 20-plus commands, skills and review agents for authorization checks, tests, PR review, CI fixes and migrations. An embedded AI Champion applied it on real projects and fed learnings back. Around it they built a shared model gateway for keys, budgets, routing, rate limits and redaction, developer telemetry to measure adoption, and traces so agent runs are inspectable; the first resident agent reviews pull requests in the delivery pipeline.
@JinjingLiang [Claude Code]
https://x.com/JinjingLiang/status/2107537480945942954
JinjingLiang gave four frontier models the same design review tasks and ranked them with an LLM Council built on an orchestrator: a Sonnet 5 president agent triggers the council members to run their own reviews, has them rate each other's work blind, and aggregates the votes. The ranking came out GPT-6.1 Sol xhigh and GPT-6 Astra high in Codex first and second, Opus xhigh and Fable 5.1 high in Claude Code third and fourth. The post says this has held across multiple council runs: the GPT models do better on research and design review tasks.
@NetMindAI [Claude Code]
https://x.com/NetMindAI/status/2107426665257394422
NetMindAI put Claude Code and Codex through eight negotiation runs. Claude Code won seven, but the detail is in how Codex lost: in several runs it gave something up without being asked, accepted the other side's explanation for its pricing, or took the worst deal it was allowed to take while there was still time to negotiate. Each choice sounded reasonable alone and together left value on the table. A procurement founder turned the study into practical rules: get something back for every concession, question supplier pricing claims, and never let the minimum acceptable deal become the goal.
@zamesin [Claude Code]
https://x.com/zamesin/status/2107555047080927497
zamesin runs simulations with Claude Code almost every day for market research. The input is customer segments and their jobs-to-be-done; a market research skill then emulates people from those segments and has them answer questions, evaluate things and decide whether to click on ads. The post is honest that this is prone to hallucination and segment drift, but for quick-and-dirty decisions that do not need high confidence it is described as amazing.
@BenRyanMe [Claude Code]
https://x.com/BenRyanMe/status/2107414891787411726
BenRyanMe got burned copy-trading a Hyperliquid wallet by looking only at the headline gains and not its past drawdowns. So they built a Claude Code tool that analyses which Hype and Strike traders are worth copy-trading given the margin their own account has available, weighting drawdown over estimated profit. The tool is linked in the post.
@FD_XYZ [Claude Code]
https://x.com/FD_XYZ/status/2107305264517173293
FD_XYZ gave Claude Fable 5.1 an Agent Wallet and $100. Every four hours it checks the market, pays for its own data, decides and writes down why; every 15 minutes it checks what it holds; nobody approves its trades. The setup is three steps: Agent Wallet is an MCP server you attach to a Claude Code routine, with keys used only inside an AWS Nitro enclave so the agent never sees them; fund it by sending stablecoins to the dashboard address, plus a few dollars on Base to pay Nansen and CoinGecko per call over x402; then the rules, most of the money in BTC, ETH and BNB only while the trend is up, a smaller slice in alts only where smart money is moving in after a contract check.
@lnkiai [Claude Code]
https://x.com/lnkiai/status/2107399371121930610
lnkiai asked two agents to make a 3D avatar and got two different methods. Codex on GPT-6.1 Sol built the model from scratch in Blender. Claude Code on Opus 5.5 proposed finding distributed models and parts and combining and modifying them instead. The side-by-side video is in the post, and the point is that the approaches differ before the quality does.
@sammyo_official [Claude Code]
https://x.com/sammyo_official/status/2107389640328306937
sammyo_official had Claude Code assemble the same short-video effects plan in two tools, EffectCraft (a free After Effects alternative) and After Effects itself, without touching either by hand, including the install. Measured on the same PC: EffectCraft is about 150 MB against 5.4 GB for After Effects, exported a 65-second 1080x1920 vertical video in about 12 minutes, while After Effects at best settings crashed once from memory pressure on a 64 GB machine with an RTX 4060 that was also running the AI. Verdict: a few rough spots, honestly good enough, but too risky to adopt for paid work yet.
@FantasistaAI [Claude Code]
https://x.com/FantasistaAI/status/2107340494963712219
FantasistaAI made a video with light effects using no After Effects and no video generation model. Claude Code on Sonnet 5.5 wrote Python: cut light assets generated by Codex, composite frame by frame with PIL and NumPy, layer starlight, halos, streaks, sparks and cherry blossom petals, handle glow, flash, screen shake and brightness in code, then encode with ffmpeg. The post calls it building video effects in code rather than generating video.
@Sprytixl [Claude Code]
https://x.com/Sprytixl/status/2107550463356715194
Sprytixl had Opus 5.5 build a motion design studio in Claude Code: layers, a canvas, an inspector, a timeline and one function underneath all of it, renderFrame(project, t). Fable 5.5 drafts scenes and first timing from a real brief (12 references, 2 fonts, 214 words of copy and a logo), then a person drags and refines; every decision lands in project.json as a slider value or keyframe so nothing gets re-prompted. Because preview and export call the same function, a 60-second film at 30 fps in 16:9, 1:1 and 9:16 is 5,400 frames from one call. The agent placed 38 keyframes and a person moved 27 by hand, 71 percent of the timing from a human eye.
@ClaudeCode_UT [Claude Code]
https://x.com/ClaudeCode_UT/status/2107403724478128498
ClaudeCode_UT found a way to produce a five-item short video with no narration recording. Tell dot you want a short on five Gmail features that speed up work; dot hands script, images and synthetic voice production to Claude Code; Claude Code exports the video with scene changes timed to the voice. A follow-up post gives the actual instruction: verify the five features against official help, structure the script, draw images that show the operation, switch scenes by the second to match the voice, and export vertical with Remotion.
@eggAIeguite [Claude Code]
https://x.com/eggAIeguite/status/2107314034127327495
eggAIeguite says Claude Code and small business are a perfect match: seven videos, each made in about ten minutes, have sold about 250,000 yen. The person knows nothing about video editing, the videos get made while left alone, and they keep selling. The post calls it business turning into a game.
@JamesPelton18 [Claude Code]
https://x.com/JamesPelton18/status/2107570650898374996
JamesPelton18 has had several recent YouTube videos edited by Claude Code. It stabilises the camera, cuts restarts and dead air, and builds the graphics for each video from scratch; then the person watches, sends notes, and it fixes them. On the back of that they are taking on three editing clients who record themselves walking through software.
@nicholasadeleon [Claude Code]
https://x.com/nicholasadeleon/status/2107477480038887791
nicholasadeleon made a launch-day trailer for a game with nothing but Claude Code on Opus 5.5 in the terminal. The ask was to make a trailer showing off the new features using an ElevenLabs API key for narration; Claude Code then played the game in the emulator, captured footage and screenshots, and stitched it all together.
@kawapo_jp [Claude Code]
https://x.com/kawapo_jp/status/2107264443008913824
kawapo_jp asked Claude Code with Opus 5.5 on high for a high-quality clip of something Gundam-like fighting something funnel-like in space, and it took about two hours. The result reads as Newtype-ish, and the sound effects in particular are satisfying. It is day 37 of a daily Claude log.
@im_inaba [Claude Code]
https://x.com/im_inaba/status/2107268417904652594
im_inaba shipped a first iOS app in about half a month of evenings after the kids were asleep, with almost everything except the landing page and App Store screenshots made by AI. The split: 3D character, app design and photo generation by Codex; iOS build and in-app icons by Codex plus Claude Code; landing page implementation by Codex; the promo video by Claude Code. Astra alone was not enough, so the second half leaned on Claude Code, and because Opus 5.5 landed mid-project the video moved into the codebase too, which made prototypes reproducible and easy to extend.
@hfujikawa77 [Claude Code]
https://x.com/hfujikawa77/status/2107287671798472709
hfujikawa77 made sleep data from a Fitbit Air readable by Claude Code through the Google Health API. It is a one-line post with a screenshot, but it is the kind of wiring that turns a wearable into something an agent can reason over.
@yasuhiks [Claude Code]
https://x.com/yasuhiks/status/2107475022206145001
yasuhiks spent an evening with Claude Code plus Strix investigating their office network and cut the holes found from six to two. One of the remaining two is in the provider's router and cannot be fixed locally, so the provider has been contacted; the other is scheduled to be closed this month. The recommendation to everyone else is to do the same.
@ingalvarezsol [Claude Code]
https://x.com/ingalvarezsol/status/2107290334946263059
ingalvarezsol asks a personal Jarvis by voice note for the week's Instagram metrics and gets them read back, without opening a computer. It was built with Claude Code and is connected to Instagram and Telegram.
@socialwithaayan [Claude Code]
https://x.com/socialwithaayan/status/2107403104958443687
socialwithaayan tried flyai, Alibaba's travel search inside Claude Code. The skill gives the agent eight search commands backed by Fliggy, so a request like three days in Hangzhou, budget 2000 per person, near West Lake comes back as real hotels with real prices; flights and trains filter by price, cabin, layovers and departure time, one keyword search covers hotels, attractions, visas and cruises, every result carries a booking link, and output is JSON you can pipe into scripts. Setup is a global npm install plus copying the skill folder into ~/.claude/skills. The honest caveat: inventory is Fliggy, prices are in CNY and examples are Chinese cities, so point it at an Asia trip first.
@gosrum [Claude Code]
https://x.com/gosrum/status/2107304336263127164
gosrum benchmarked two local LLM setups with ts-bench for people choosing between Strata plus Qwen3.8-Flash Next and Qwen3.8-27B. Strata with Flash Next was more than twice as fast as llama.cpp with the 27B, remarkable on an RTX 5090 with only 32 GB VRAM, but the IQ3_S quantization seemed to hurt: paired with Claude Code it could not get every question right on medium and fell into a loop on low, while the 27B scored full marks even on low. Paired with Codex, Flash Next used far more tokens but still scored full marks on low. Recommendation: 27B at 4-bit if you want parallel inference or stability, Strata plus Flash Next if you run one stream and want more than 27B.
@victorianoi [Claude Code]
https://x.com/victorianoi/status/2107423756603777075
victorianoi came back to Claude Code after months of preferring Codex, for two features. Project management is better thought out: a coordination thread sends tasks to already-open threads when that makes sense or opens new ones, and at a glance you can see which threads are blocked waiting on you, which are done and can be archived. Remote control latency from the phone is also much lower than opening Codex. Add Opus 5.5 being good, fast and cheap on subscription and the switch was made; the one thing missed is not being able to use the Claude Code subscription elsewhere, such as in Hermes.
@lklkfafa1 [Claude Code]
https://x.com/lklkfafa1/status/2107609682064076830
lklkfafa1 wrote about using OpenAI's dots as a single front door for work previously sent separately to Claude Code and Codex: organising requests, checking progress and verifying what came back. The problem that surfaced was not knowing what is currently stopped and which items are waiting on a reply, being under the impression of waiting on the AI when in fact the person was the blocker. The fix was having it build a dashboard, which is where the post ends.
@jsnnsa [Claude Code]
https://x.com/jsnnsa/status/2107272456822210984
jsnnsa pushed back on the flex of using the same tools as everyone else like Claude Code when the implicit bet of a startup is building something nobody could before. At spawn, a game engine where friends can change a running multiplayer world from phones and computers, the process itself was rebuilt: a player asks for something in Discord, AI picks it up and routes it, a human approves, AI builds and ships it, and the player gets the feature that day, sometimes within an hour. Fewer than ten people build the engine, tools, discovery, monetisation, native apps and community platform that way.
@Slonski_rt [Claude Code]
https://x.com/Slonski_rt/status/2107538401713176839
Slonski_rt summarised a Dive Club talk by Megan Choi, head of design for Claude Code, who types one sentence and gets five prototypes back. The /prototype skill runs a chain: five versions, Claude picks one and defends it, build, browser check, PR with a screenshot. The talk also covers git worktrees for parallel sessions, sending small UI fixes to the cloud, PR automation and scheduled design reviews, and the point that even inside Anthropic the final taste stays with a human: a second opinion, not the final say.
@doodlestein [Claude Code]
https://x.com/doodlestein/status/2107564307852497406
doodlestein posted a PSA and a prompt for the $250 cloud-session credit on each Claude Max 20x account that expires in two days. Claiming needs GitHub connected, then a session on one of your repos with a prompt. The generic prompt shared tells Claude to read the comprehensive plan and the beads, figure out the most momentous remaining gaps in features and functionality, get as much of those done as possible in the session rather than minutiae or ceremony, and commit to GitHub. A second PSA: everyone also got one banked weekly-limit reset expiring Oct 22, and the advice is to wait until you actually hit the limit before clicking it.
@shipwithstef [Claude Code]
https://x.com/shipwithstef/status/2107371930802118704
shipwithstef watched friends try Auto Mode in Claude Code and go straight back to --dangerously-skip-permissions, and argues the real issue is skipping the setup, interview and critique loop. Out of the box Claude trusts the current repo and its remotes and nothing else; your GitHub org, S3 buckets and staging APIs are strangers. The recipe: run /auto-mode-setup, which scans remotes, configs and command history to draft a trusted environment; then interview Claude in plain language about what it sees and what to trust; then run claude auto-mode critique to catch vague or overlapping rules and claude auto-mode config to see what is active, always keeping $defaults in any allow or deny list so you do not silently delete the built-in blocks on force-pushes and data exfiltration.
@claudecode84 [Claude Code]
https://x.com/claudecode84/status/2107325059220316515
claudecode84 pointed out that /code-review in Claude Code may have been finding more bugs than it showed. Since the Oct 2 update you can set the number of findings: /code-review --max-findings all shows everything, --max-findings 20 caps it, --max-findings default restores the limit, and Claude Code remembers the setting. The recommended moments are before merging a large PR, after Opus 5.5 has rewritten files, and before shipping anything around auth or payments. The follow-up prompt after review: extract every finding, sort by file and severity, act only on Critical and list the rest, always show the diff first, and do not edit until the person says go.
@ClaudeCode_UT [Claude Code]
https://x.com/ClaudeCode_UT/status/2107312746782200238
ClaudeCode_UT noticed tokens being consumed before asking Claude Code to do anything: CLAUDE.md and skill descriptions are loaded at the start of every conversation, so long procedures you rarely use shrink the room left for actual work. The check is /context, looking at three items, Memory files, Skills and Messages. The rule in the follow-up: keep only the common rules every session needs in CLAUDE.md, split long procedures into separate files read only for the tasks that need them, and review unused integrations with /mcp before deciding how many lines to cut.
@davekiss [Claude Code]
https://x.com/davekiss/status/2107614268480954449
davekiss tried a Claude Code mod by Alex Hillman that replaces auto-compact with a visible, editable context carry-over. Near the context limit it writes a brief to disk, what is in progress, decisions, your last message, the next step, then clears and lets a fresh session pick it up. Files and commits come straight from the transcript so they do not depend on the model remembering. It locked up once in a day of use, but the verdict is that it is a nice add worth keeping on.
@Shinmaboroshi [Claude Code]
https://x.com/Shinmaboroshi/status/2107470946118549542
Shinmaboroshi built five Claude Code mods in a week and recorded a walkthrough: a clean checklist view that hides all the code, a one-click model and effort picker, a dock that runs a whole team of agents at once, a photo and video studio driven by the Higgsfield MCP, and a mini racing game to play while Claude works. The video also covers how to build your own mods, how to save and install them as plugins, and what they cost; the framing is that Claude Code can now add buttons, panels and slash commands to itself without the user writing code.
@mitchellh [Claude Code]
https://x.com/mitchellh/status/2107577887159386152
mitchellh published a general-purpose terminal specification, OSC 7501, that lets any program tell the terminal what it is doing: idle, working, waiting, finished or failed, and why. The motivating case is the agentic inbox problem: over 250 different agent orchestrators each implement heuristics to detect whether tools like Claude Code are working, blocked or done, and one orchestrator's commit history shows around ten Claude Code compatibility fixes in three months. Heuristics, proprietary protocols and out-of-band APIs all fail (O(N) integrations, broken over SSH and inside VMs), so a deterministic escape sequence that also serves Homebrew, Terraform and Cargo is proposed instead.
@virgilerietsch [Claude Code]
https://x.com/virgilerietsch/status/2107463995070291985
virgilerietsch released BlitzClean, a free open-source RAM monitor and disk cleaner for Mac, built because they kept running out of storage, never knew what was eating RAM, and the previous tool broke on the macOS 27 beta. It shows CPU, RAM and free disk in the menu bar, ranks apps and AI agents (Claude Code, Codex, Cursor) by RAM so you can pause or quit the ones you forgot about, finds what fills the disk, and cleans caches, node_modules, simulators, Docker and old worktrees with review first. MIT, fully local; the launch video was made with Opus 5.5 on medium.
@Da7_Tech [Claude Code]
https://x.com/Da7_Tech/status/2107608238028148818
Da7_Tech was down to 26 GB free on a Mac, with the space in old projects, AI models, recordings, backups and chat histories rather than caches, so they wrote Storage Rescue, a skill that teaches agents to free space without losing anything. Offload mode moves big files to an external drive, verifies with SHA-256 twice, and only then deletes the Mac copy; Reclaim mode clears caches with each tool's own command and sends files to the Trash first. The agent surveys the disk, then asks per group whether to move, delete or keep, and nothing happens without a clear yes. Result on that Mac: 968 GB used before, 366 GB after. Plain text, macOS only, works with Claude Code, Codex, Cursor, Factory Droid, Devin and Hermes.
@nevermind_turki [OpenClaw]
https://x.com/nevermind_turki/status/2107529960852210106
nevermind_turki runs OpenClaw and Hermes on an old machine with recurring jobs, one of which logs into the university Blackboard daily and updates a dashboard. Yesterday the agent asked for the username and password again, was told it already had them, and was left alone in Telegram. Later it turned out it was trying to embed its memory to save the workflow, including those credentials, found that the OpenAI and DeepSeek balances it used for embeddings were exhausted, inspected the machine's capabilities, downloaded a local embedding model, and finished the task. The run took over 120 seconds, but the idea worked.
@HuaHua_BTC [OpenClaw]
https://x.com/HuaHua_BTC/status/2107451976380547089
HuaHua_BTC walked through Acurast's tutorial for deploying OpenClaw onto phone nodes in its network via Cargo, so an agent keeps running after your own computer is off for the deployment period you set. The official example calls models through OpenRouter while the phone runs the agent program, so compute and model costs are billed separately. The caveat to handle up front: when the deployment expires, local data including config and session history is deleted, so anything you need long term must be saved elsewhere. The suggested approach is one small scheduled task first, check it completes on time and what it costs, then test continuous runs.
@Box [OpenClaw]
https://x.com/Box/status/2107561622441222622
Box published a tutorial on OpenClaw 2.0's /loop against a Box deal room: one prompt, and the agent keeps checking the folder, updating the risk register as new documents arrive instead of stopping when the chat ends. It is a vendor post, but it is one of the few concrete non-coding loop examples from a large enterprise software company.
@hisnameisjimmy [OpenClaw]
https://x.com/hisnameisjimmy/status/2107547765484163415
hisnameisjimmy uses OpenClaw primarily for family management: aligning schedules between the two parents, pulling out what the school is asking for from emails, and finding weekend activities appropriate for the kids' ages. It is a short reply, but it is the most specific description of the household use case in the window.
@MarketPulseFX1 [OpenClaw]
https://x.com/MarketPulseFX1/status/2107429730370883688
MarketPulseFX1 keeps Hermes for personal things but runs Argus, a project started before Hermes existed, on an autonomous online server with OpenClaw, which they rate highly for automations, workflows and multi-agent management. The setup now has a layer above it: a general context lives in a Claude Cowork project and a second brain in OpenClaw, and it is Claude Cowork that works with the person and then monitors Codex and Claude Code directly on the VPS where OpenClaw runs, for prompts, code or diagnostics. The result is barely needing to be in front of the computer to develop.
@JCalafat_ [OpenClaw]
https://x.com/JCalafat_/status/2107536154153156733
JCalafat_ is hooked on OpenClaw with two instances, a personal one on Hostinger and another in Docker at work, all still experimental. Being able to ask it small things over Telegram is the part they love; development through it is not perfected yet, but it already gets some tasks done.
@Dennis_Rye [OpenClaw]
https://x.com/Dennis_Rye/status/2107564495421759695
Dennis_Rye owns a printer for the first time in almost 40 years, and an agent set it up, but not OpenClaw: after 24 hours of permission issues, configuration issues and solutions that did not work it had produced nothing, while switching to Hermes got ahead of the OpenClaw setup in 15 minutes. The post is explicit that it is a shame, that the multiplayer idea is appealing and OpenClaw will probably get another look, and that Grok Bot is not forgotten either.
@anthonyronning [OpenClaw]
https://x.com/anthonyronning/status/2107575609564258594
anthonyronning spent weeks fighting a fresh OpenClaw 2.0 install trying to make it useful and got endless manual patches and constant breakage, then migrated to Hermes and had everything working in ten minutes. The post says this has been the pattern since January and that a year of growth and enterprise partnerships has not produced a stable OpenClaw; in their words, the actual builders continue to win.
@rowantrollope [OpenClaw]
https://x.com/rowantrollope/status/2107519033369411975
rowantrollope barely uses OpenClaw anymore and asks whether the same will happen to the new crop of agents. Deploying it was many painful hours but it was cool, then use fell away until a few core jobs remained: a central shared brain and memory for all their agents, a daily news updater, and event watches. The question posed is what has actually changed with Instinct, Muse and Dots, since long-term daily active use is the key, with a bet that Muse's team will have the best discipline on measuring and iterating through that problem.
@DevaiahShrithan [OpenClaw]
https://x.com/DevaiahShrithan/status/2107386733717557282
DevaiahShrithan summarised a 20-minute AI Engineer talk by Neo4j's Jeremy Adams. A Craigslist Mac mini came with OpenClaw pre-installed, which they read as a red flag, so they dug a Raspberry Pi 4B out of a closet and picked nanoclaw, about 15 source files with agents in Docker containers, zero inference on the Pi, cloud as the brain. On a plane, WhatsApp worked without paid wifi so the claw stayed reachable from the air; the memory schema came from European policing (person, object, location, event, organisation) and the claw wrote the skill mid-flight. A physical button on the Pi's pins recorded voice notes booth to booth at the conference with local Neo4j as the offline fallback, and themes like evaluation and observability surfaced after upload.
@amQnese [OpenClaw]
https://x.com/amQnese/status/2107499359386612199
amQnese has been building an AI agent companion like dots, bot, Hermes or OpenClaw since last year, when it was all still new, inside the company's main communication app (Lark). One capability now in daily use: it triages real staging and production issues and opens the PR. The daily routine has collapsed to opening the repo, reading the review status from another more powerful agent, reading the PR summary, checking code where needed, and merging.
🗣 User Voice
User Voice
Approval and handoff between agents is the gap people are hand-rolling: @realKevinPuray built a local approval bot because Claude Code and Codex cannot approve each other's prompts, @lklkfafa1 had to build a dashboard just to see which tasks were waiting on a human, and @mitchellh counted over 250 orchestrators screen-scraping terminal output to guess whether Claude Code is blocked.
Context and cost are the daily tax: @gippp69 and @biektive both found the savings in routing and memory rather than model choice, @ClaudeCode_UT showed tokens burning before the first prompt via CLAUDE.md and skill descriptions, and @davekiss wants compaction to be visible and editable instead of automatic.
The harness is not interruptible enough: @championswimmer cannot change TUI settings while a task runs, @DanielSmidstrup asked what people do when the usage limit hits mid-flow, and @dataduck_ hit the Max credit wall and found Codex has no equivalent of Claude Code's dynamic workflow.
Cloud sessions still do not match local environments for some: @PovilasKorop says Claude Code web and Cursor Cloud have the wrong tools and failing tests because the cloud env is not their local env.
OpenClaw's reliability is the recurring complaint: @anthonyronning and @Dennis_Rye both left for Hermes after days of permission and config errors, @tdguchi2 was tired of repeating things it already had in memory, and @matthewcarano points out it rereads the whole conversation on every tool call; on the other side @victorianoi wants the Claude Code subscription usable from Hermes, and @mariagorskikh wants a universal protocol so an OpenClaw can talk to a friend's Muse.
Approval and handoff between agents is the gap people are hand-rolling: @realKevinPuray built a local approval bot because Claude Code and Codex cannot approve each other's prompts, @lklkfafa1 had to build a dashboard just to see which tasks were waiting on a human, and @mitchellh counted over 250 orchestrators screen-scraping terminal output to guess whether Claude Code is blocked.
Context and cost are the daily tax: @gippp69 and @biektive both found the savings in routing and memory rather than model choice, @ClaudeCode_UT showed tokens burning before the first prompt via CLAUDE.md and skill descriptions, and @davekiss wants compaction to be visible and editable instead of automatic.
The harness is not interruptible enough: @championswimmer cannot change TUI settings while a task runs, @DanielSmidstrup asked what people do when the usage limit hits mid-flow, and @dataduck_ hit the Max credit wall and found Codex has no equivalent of Claude Code's dynamic workflow.
Cloud sessions still do not match local environments for some: @PovilasKorop says Claude Code web and Cursor Cloud have the wrong tools and failing tests because the cloud env is not their local env.
OpenClaw's reliability is the recurring complaint: @anthonyronning and @Dennis_Rye both left for Hermes after days of permission and config errors, @tdguchi2 was tired of repeating things it already had in memory, and @matthewcarano points out it rereads the whole conversation on every tool call; on the other side @victorianoi wants the Claude Code subscription usable from Hermes, and @mariagorskikh wants a universal protocol so an OpenClaw can talk to a friend's Muse.
📡 Eco Products Radar
Eco Products Radar
Codex: named in roughly a third of all posts, the default second agent next to Claude Code
Opus 5.5 and Sonnet 5.5: the lead and worker pair in every team setup; Fable 5.1 as the skeptic
Hermes: the migration destination for frustrated OpenClaw users
Grok Bot, Muse, Dots and Instinct: the hosted personal-agent wave everyone compares against
Jev (TypeSafe): decision model behind the memory mod and several routing posts
Treg: open-source Clay alternative, four separate users ran leads from Claude Code
Antseed: multi-provider model marketplace promoted heavily as a way around limits
Claude Code Mods: new plugin type behind five separate how-to posts
Cursor: still the third coding tool named, mostly in comparison
Higgsfield and ElevenLabs: the video and voice layer in film, trailer and motion posts
Blender and Unreal Engine: the 3D targets for Claude Code this window
Herdr and tmux: the session-management layer under multi-agent terminals
Octop (Tencent): open-source multi-user agent workspace launched this window
OpenCode: named alongside Claude Code in local-model and Antseed posts
Codex: named in roughly a third of all posts, the default second agent next to Claude Code
Opus 5.5 and Sonnet 5.5: the lead and worker pair in every team setup; Fable 5.1 as the skeptic
Hermes: the migration destination for frustrated OpenClaw users
Grok Bot, Muse, Dots and Instinct: the hosted personal-agent wave everyone compares against
Jev (TypeSafe): decision model behind the memory mod and several routing posts
Treg: open-source Clay alternative, four separate users ran leads from Claude Code
Antseed: multi-provider model marketplace promoted heavily as a way around limits
Claude Code Mods: new plugin type behind five separate how-to posts
Cursor: still the third coding tool named, mostly in comparison
Higgsfield and ElevenLabs: the video and voice layer in film, trailer and motion posts
Blender and Unreal Engine: the 3D targets for Claude Code this window
Herdr and tmux: the session-management layer under multi-agent terminals
Octop (Tencent): open-source multi-user agent workspace launched this window
OpenCode: named alongside Claude Code in local-model and Antseed posts
Comments