Super User Daily: 2026-10-03
October 1 was Mods day. Anthropic opened up Claude Code itself to a few lines of TypeScript, and within hours people had a spinner drawing live cartoons of what the agent is doing, a progress bar with sound, a panel listing every URL Claude touches, a sandbox gate that decides which commands run locally, and an Apple Reminders sidebar. The more interesting part is what the mods are for: almost every one makes the agent's work visible, because the thing users trust least is what happens while they look away. The other half of the feed was not code at all. A robot power board went from first commit to a JLCPCB order in under 24 hours, a Harvard physicist ran 36 manuscripts across 18 fields in three months, a WordPress agency on an $800 retainer delivered years of backlog in days, and a game-modding skill pack decompiled Terraria overnight and added homing missiles. OpenClaw users spent the day comparing their self-hosted setups to Dots, and the ones who stayed explained why in very specific terms: GPS, ambient audio and message history fed in real time, and the ability to fix it yourself when it breaks.
@VectorCrossProd [Claude Code]
https://x.com/VectorCrossProd/status/2105573388878270839
VectorCrossProd built a real PCB without drawing a schematic or placing a single part by hand, under 24 hours from first commit to a JLCPCB order. Claude Code wrote the scripts while KiCad, Freerouting, FreeCAD and Blender did the work, and the author reviewed only at checkpoints set in advance. The board, Kookabus-01, is a 64 by 62 mm robot power board with two packs in, one load out, ideal-diode hot-swap so the load never browns out, and an INA226 reporting volts, amps and watts over Qwiic. Schematic, layout, Gerbers, BOM, pick-and-place, datasheet, enclosure and even the promo film all came out of a written brief, and boards are being assembled now.
@yupi996 [Claude Code]
https://x.com/yupi996/status/2105461946208354750
yupi996 broke down universal-modder, the open-source pack that came out of someone letting Opus 5.5 decompile Terraria overnight and waking up to homing missiles and tactical nukes in the game. Installed in Claude Code, it takes one sentence about what you want changed, then decompiles, draws sprites, makes sound effects, tests in the running game and cuts its own demo video. The rules it gives the agent are the part worth copying: keep a log while working so compaction cannot wipe its memory, stop and change approach after the same error appears three times, and accept only in-game screenshots and logs as proof that a change worked. The funniest rule bans pkill -f, because the pattern would match and kill the agent itself.
@vegardwikeby [Claude Code]
https://x.com/vegardwikeby/status/2105722450126508091
vegardwikeby spent a week inside Claude Code on a client WordPress site and says it delivered years of work the client's $800 a month retainer could never have covered, done in days. The rebuild hit 100 or close to it on Lighthouse for every page, cut the site from 25+ plugins to a handful, replaced an outdated theme with a custom Gutenberg-native one, merged and converted pages while keeping every redirect, and checked the new sitemap against the old one. Translations ran through WPML's XLIFF export and import because Claude matched the client's tone far better than machine translation. The author expects the next site to take half the time, since the whole chat history is about to become a plan and a series of prompts.
@Klonzu [Claude Code]
https://x.com/Klonzu/status/2105738188115329460
Klonzu summarized a Harvard physicist who ran 36 manuscripts across 18 fields in three months with Claude Code. The setup is simple and copyable: one session per project, a master session that coordinates the rest, subagents for long runs, and every result saved to markdown. The warning is the valuable part. Claude loves to declare victory, and it was once proud of a proof that rested on one unproven lemma, which turned out to be the whole proof.
@lbtech [Claude Code]
https://x.com/lbtech/status/2105747234071388189
lbtech turned one Linux machine into a software team: agent-stack runs about 70 Claude Code and Codex sessions as real teams, one per project, with a lead, architect, builders, test authors, reviewers, QA and an integrator coordinated by OpenRig over a durable work queue. Every change follows the same path: tests are written first and locked, an agent builds, a reviewer from the other model family checks it, QA tests, a merge gate decides on that exact commit, and a fresh agent then uses the feature end to end like a person would. rig-console is the mission control showing who is working, idle or stuck with the reason, live terminals, model quotas and system health at about 1% of one core. Cross-family review is the detail that matters, since two models from the same family tend to miss the same bugs.
@GoSailGlobal [Claude Code]
https://x.com/GoSailGlobal/status/2105598715394474433
GoSailGlobal walked through three open-source Claude Code skills from creator Huang Bai that turn one sentence into a finished talking-head video: script, digital-human delivery, B-roll, compositing and frame-sampling QA. The script skill learns the creator's past style and outputs a three-column storyboard with no line over 15 seconds, the avatar segments are generated with Seedance from one face photo plus eight seconds of voice and checked word by word with Whisper so only flubbed segments get re-run. The rough-cut rules are hard-won: cut only inside pauses snapped to the quietest 20 ms within 0.25 seconds, pick speed-ups by frame rate (1.2x for 25 fps, 1.25x for 24 fps) so they map cleanly to 30 fps, and leave a half to one second of breath after each line. Every paid step gets a quote first and waits for the word submit, and the final checklist samples a frame every two seconds and normalizes to -14 LUFS.
@redp314 [Claude Code]
https://x.com/redp314/status/2105647218992550335
redp314 saw Opus 5.5 build a LEGO Microduck and wondered what the 2,000-year-old version would look like, so they asked Claude Code for a Roman mosaic instead. The result has 7,878 tiles, each a real 3D stone, laid row by row the way a mosaicist would. There is no image model and no video model, just code running in the browser, and it holds up when you zoom into the eye. It is a neat proof that code is now a viable medium for craft-style visual work, not just diagrams.
@anshuc [Claude Code]
https://x.com/anshuc/status/2105773281936650247
anshuc vibe-coded a custom spinner on day one of Mods that watches what the main agent is doing and uses Sonnet 5.5 to turn it into little cartoons in real time. It is the most charming answer yet to the dead time while an agent works: instead of a blinking cursor you get a running illustrated commentary. The same author also got Doom running inside the Claude Code spinner. Silly, yes, but it shows how deep the new hook goes: the UI loop itself is now user territory.
@brankopetric00 [Claude Code]
https://x.com/brankopetric00/status/2105759582261760488
brankopetric00 noticed that when Claude Code researches something you see the answer but not where it came from, so they built a mod that shows every URL Claude touches live in the terminal. That covers searches, page fetches, curl calls and browser tabs. The practical use is checking sources and catching the agent reading outdated docs before it builds on them. The repo is public, and it is exactly the kind of transparency feature people used to file feature requests for.
@kirillvserditov [Claude Code]
https://x.com/kirillvserditov/status/2105790255144063241
kirillvserditov built a live progress bar for plans in a single session after Mods shipped, with stages, sounds and multiple tasks running side by side. It turns a long plan into something you can glance at from across the room instead of reading scrollback. The fact that it took one session says a lot about how low the barrier now is to reshaping the tool around your own attention.
@dani_avila7 [Claude Code]
https://x.com/dani_avila7/status/2105754717854777361
dani_avila7 published a Jev plus Vercel Sandbox mod for Claude Code: it spins up a sandbox on Vercel while Jev, a small decision model, classifies which commands should run inside the sandbox and which can run locally. It installs with one npx command from claude-code-templates. This is the pattern Mods make possible: a cheap classifier sitting directly in the agent loop as a safety gate, rather than another line in CLAUDE.md asking the model to be careful.
@viticci [Claude Code]
https://x.com/viticci/status/2105785691569533333
viticci shipped RemCTL 2.1.0 with a Claude Code plugin and mod, so Apple Reminders show up inside Claude Code. You can always see what is left to do today or in a specific list, and there is even a sidebar. It is a small thing that says a lot: the coding agent window is becoming the place where people want their whole day visible, not just their repo.
@attacomsian [Claude Code]
https://x.com/attacomsian/status/2105768990274715653
attacomsian, who used Claude Code to build their apps Vitals and Flit, made their first mod the most obvious one: something that pings them when a long task is done so they stop staring at the terminal. It is the smallest possible mod and probably the one with the biggest quality-of-life return. The line that sticks is the loop it closes: Claude Code built their products, and now they get to rebuild Claude Code itself.
@Av1dlive [Claude Code]
https://x.com/Av1dlive/status/2105757532790903192
Av1dlive did the smart thing before writing any mod: asked Claude to go through their Codex and Claude Code workflows and say what recurring problems needed a mod versus a hook, skill or settings change. The suggestions were concrete: a context guard that saves progress before compaction, a watchdog for low disk space and orphan processes, a loop detector for repeated failed attempts, a review step that surfaces corrections worth saving as memory, and a post checker for repeated hooks and unsupported attributions. Mining your own session history first is the right order, because the mods worth building are the ones that answer the questions you keep stopping to ask.
@mikepat711 [Claude Code]
https://x.com/mikepat711/status/2105613676287824216
mikepat711 asked Grok Bot to send a job to Cursor, which spun up a cloud coordinator and two workers to build an explainer-video pipeline, then handed it down to a Cursor worker living on their Mac Mini. Now the pipeline is fixed: Claude Code on the Mini, signed into a Claude Pro subscription, writes the research, script and animation plan; Python draws the animations; Kokoro records narration; ffmpeg adds music and captions and exports; the MP4 lands in iCloud. Every new educational video is just a topic sent to Grok Bot, with no cloud agents involved unless the pipeline itself needs editing. The first output explains how the power grid works.
@takuchang_n [Claude Code]
https://x.com/takuchang_n/status/2105574112030503234
takuchang_n listed the toolchain behind a finished video: Claude Code on Fable 5.1 ran the whole production and drove each tool, Higgsfield made the character images and video, ElevenLabs did voice, BGM and sound effects, and After Effects handled compositing and text animation. The notable part is that After Effects is operated by Claude through MCP, the bridge that lets an AI drive the app directly. A pro motion-graphics tool being steered by an agent is a different category from generating clips and stitching them.
@shupeiman [Claude Code]
https://x.com/shupeiman/status/2105634243200385531
shupeiman shot one session on three iPhones plus an Osmo Pocket for four camera angles, then threw all the footage at Claude Code and asked for a Pivot-style edit. Opus 5.5 handled the multi-angle cutting easily, and the author says they did not make a single correction. Multi-camera editing used to be the step that kept solo creators on one angle, and this is the kind of chore that is quietly disappearing.
@sl1ma4 [Claude Code]
https://x.com/sl1ma4/status/2105592053874700360
sl1ma4 gave Claude Code one prompt: make a dynamic 30-second motion graphics video about Uptimepage, not too fast so people actually understand it, use three.js. Twenty-six minutes later there was a finished 1080p60 video. It cost $6.74 on Sonnet 5.5 with 204k output tokens. Those three numbers are the useful part: they make a launch video a line item you can budget, not a freelancer search.
@tsubotax [Claude Code]
https://x.com/tsubotax/status/2105526804870246862
tsubotax, a designer, explains that dropping Figma does not mean handing design to AI. The judgment and trial-and-error are still their own, maybe more than before; what changed is how judgment becomes form. Through Claude Code in natural language they compare kerning, try several animation options, tweak SVGs and ship the implementation in one continuous flow. The point is that AI replaced the tool operation they were weak at, so ideas that used to be blocked by tool skill can now be built by the designer directly.
@MichLieben [Claude Code]
https://x.com/MichLieben/status/2105778817327616411
MichLieben connected Claude Code to folk, their CRM, plus the ColdIQ MCP, alongside tracking 2,000+ product signups, and wrote up the plays they run before ever buying another lead list. Pull closed-lost deals from the last 12 months, have Claude read call transcripts and put the buyer's exact objection next to each account, then check whether that objection still holds: is the integration now supported, is the blocker still at the company. Track where former champions moved and qualify the new company first, test whether ICP criteria actually separate won from lost deals on held-out data, and trigger the owner when a signup starts checkout. The discipline throughout is evidence first: only draft a follow-up when you can explain why the conversation would be different this time.
@RCIllingworth [Claude Code]
https://x.com/RCIllingworth/status/2105734564802933155
RCIllingworth, who has sent more than 50 million cold emails in two years, rebuilt the whole stack inside Claude Code and says a week of tedious manual work now takes an afternoon with no drop in output quality. Their diagnosis is that cold email is rarely a copywriting problem; something breaks in the chain of repeatable steps from finding companies to reading replies. The workflow runs seven steps from ICP to post-send analysis, with tier 1 and tier 2 bucketing and a parallel enrichment trick that turns 250 contacts into a 30-minute job instead of a 12-hour Clay job. The post-send loop decides which emails to rewrite and which to kill.
@codyschneider [Claude Code]
https://x.com/codyschneider/status/2105764696691192319
codyschneider argues your SEO subscription does less than Claude Code with your own data. Put Search Console and GA4 into a data warehouse, give Claude Code access, and it can find page-two keywords worth pushing to page one, rewrite titles, headings or articles to get them there, map search traffic to the conversions you care about, find orphan pages and missing links to money pages, send a Monday Slack report with week-over-week movement, and build a dashboard that updates hourly. The pitch is blunt: for a SaaS paying an agency $60k a year, this is the swap.
@masashi20555444 [Claude Code]
https://x.com/masashi20555444/status/2105768465957310772
masashi20555444, an IT consultant who has made documents for over 20 years and still builds slides twice a week, turned the process into a Claude Code system and published it as a book. Typing its document-creation slash command makes the AI ask exactly four questions, read the materials you dropped in and ask about contradictions and gaps, stop at an outline for confirmation, then check each item and finish in the company template. The human only answers, chooses and approves. Compared with asking in chat each time, the questions are always the same, the output always matches house format, and you can stop midway and resume.
@neil_xbt [Claude Code]
https://x.com/neil_xbt/status/2105602120225333507
neil_xbt measured one real Claude Code session: the agent wrote 59K tokens but had to re-send 7.4M over 60 turns, with only 7 messages from the human. 77% of the cost was the conversation being re-sent every turn and only 23% was the model writing, and 11 of the 60 turns ran with more than 150K tokens of context, which is where the money went. Five rules cut most of it: grep for the symbol and read 40 to 80 lines around it, never re-read a file already in context, batch independent tool calls into one turn, run the one relevant test instead of the suite, and past about 100K write a five-line handoff and start fresh. The meter that produced the numbers reads the transcript Claude Code already writes, with zero dependencies.
@buildwithhassan [Claude Code]
https://x.com/buildwithhassan/status/2105693275252195748
buildwithhassan used to think Claude Code burned limits by writing code, then realized it was re-reading the same context on every turn: web pages it pulled in, files it scanned, loops it got stuck in. The habits that fixed it are worth stealing: /clear when switching tasks, /compact before about 150K, check /context to find the MCP server whose giant tool list is taxing every message, remove unused MCP servers and skills, run /insights and /skill-doctor. Two subtler ones: do not leave a session idle for more than an hour because the cache expires and has to be rebuilt from scratch, and do not spawn subagents for small jobs since each starts cold. Max effort is not a default either, because on some models it burns several times the tokens for barely better results.
@CoinSh0t [Claude Code]
https://x.com/CoinSh0t/status/2105644753383494137
CoinSh0t wrote up /doctor prompt-audit, built into Claude Code 2.1.283, which reads CLAUDE.md, skills, subagents and custom commands and flags everything written for models that no longer exist: CRITICAL and YOU MUST in caps that newer models overreact to, think-step-by-step scaffolding, paths to deleted files, renamed scripts, skills that contradict CLAUDE.md. The catch is that it skips the personal skills folder by default. In the example cited, a setup with 49 skills and 286 subagents produced 66 findings in 21 minutes without touching a single skill, and only after adding claude --add-dir ~/.claude did the real rot appear: hardcoded paths from another person's Mac and four skills calling plugins that no longer existed. The two runs cost $20.31 and about 34 minutes, which is cheap insurance after every model upgrade.
@ai_suxiaole [Claude Code]
https://x.com/ai_suxiaole/status/2105486608946589861
ai_suxiaole names a failure everyone has hit: Claude Code writes the code, tests pass, type checks are green, it reports the task done, and the app does not actually work. Telling it to be more careful does not help; writing down when something counts as done does. The prompt they hand Claude Code: list observable acceptance criteria for this request, run existing tests, type checks and linter, launch the app and walk the affected flows, check page state, API responses and key metrics, give pass or fail with evidence for each criterion, keep fixing until all pass, and only then report changes, evidence and remaining risks. Code generated is not the same as task complete.
@ClaudeCode_UT [Claude Code]
https://x.com/ClaudeCode_UT/status/2105507540041875867
ClaudeCode_UT demonstrated plan mode on a small form-handling fix where the implementation approach was still undecided. Before editing anything, Claude surveyed the files and returned not just empty-string handling but whitespace-only, missing and null cases, plus an open question about whether callers expect an exception or an error return. The demo stopped at the plan and confirmed the source file was untouched. Finding spec gaps before code exists is the cheapest place to find them.
@seiichi_satoweb [Claude Code]
https://x.com/seiichi_satoweb/status/2105796148623753422
seiichi_satoweb recommends a simple trick for Claude Code article-writing agents: add a reader role that is given none of the writing rules. Because it has not been told what the article is supposed to do, it reacts like an actual reader and flags what is confusing. The author says hard-to-follow passages drop sharply once it is in the loop. It is the writing equivalent of the cross-family code reviewer: a checker that does not share the author's assumptions.
@_3912657840 [Claude Code]
https://x.com/_3912657840/status/2105493320814448896
_3912657840 runs a Codex-centered system on the $100 plan with Sol 6.1 at xHigh across parallel tasks and still uses only about 25% of the weekly allowance. Astra handles large design imports from ChatGPT Pro and big audits, and when Sol gets stuck, especially on graphics-heavy tasks, the task goes to Opus 5.5, which fixes it while working out what Sol did wrong; that lesson is turned into knowledge and fed back into workflows and skills. To use Codex and Claude Code across one project, they built a bridge with a Dot named Takeshi standing in the middle to monitor, push and operate the project. Opus is effectively a workflow consultant on a $20 plan, which is a clever division of labor by cost.
@Teslanaut [Claude Code]
https://x.com/Teslanaut/status/2105807710122086411
Teslanaut has Claude Code managing a ComfyUI machine: testing model setups for the hardware, applying updates and optimizations, and documenting everything in an HTML gallery app. The coding for that app is now offloaded to an M4 Max running Qwen 3.8 Flash Next with the pi coder, and both Claude and Qwen audit the generated images and compare each other's results. When idle, the same machine keeps checking for updates and PRs to Strata to test them, and there is a launcher TUI and hardware monitor on top. It is a good picture of a home lab where the frontier model is the manager and the local model is the labor.
@tanabe_fragm [Claude Code]
https://x.com/tanabe_fragm/status/2105475012732039665
tanabe_fragm just learned that Claude Code can operate Codex and generate images with GPT Images 2.5. As a ChatGPT Plus subscriber, routing image generation through the subscription they already pay for saves a separate image-generation cost. It is a small discovery, but it is the pattern of the week in miniature: agents calling other agents so users can spend the meters they already own.
@TiagerBao [Claude Code]
https://x.com/TiagerBao/status/2105541066674078011
TiagerBao covered motion-video-kit, a skill that gives Claude Code a full commercial-video workflow instead of letting AI stitch random shots. The author dissected 28 professional SaaS launch films into motion rules, storyboard methods, Three.js 3D patterns, audio specs and QA checks, with AI-generated assets, HTML and GSAP motion and a code-controlled timeline. The Gauntlet review is the clever part: the agent that makes the video never grades itself, a fresh critic reviews each render, lists issues, and the loop runs 3 to 5 rounds. Animations must be deterministic, so jumping to the same frame always gives the same image, and delivery includes storyboards, source files, asset logs and review records, not just an MP4.
@pratyushrungta [Claude Code]
https://x.com/pratyushrungta/status/2105690139330773265
pratyushrungta built dissect, a Claude Code skill that takes apart any video and writes a recipe for remaking its format. Tested on a Kurzgesagt short, the remake built from the blueprint came out pretty close to the original, though not perfect. It works best on Shorts, Reels and TikToks: faceless explainers, motion graphics, fast-cut edits and captioned talking heads. It is free, open source and installs as a plugin, which makes format reverse-engineering a one-command step.
@burakerolai [Claude Code]
https://x.com/burakerolai/status/2105573208304803945
burakerolai took it personally when someone said Claude cannot create App Store screenshots as a panorama, and built a Claude Code agent that does exactly that. It analyzes the app, captures the real screens, creates a connected panoramic screenshot set for the App Store and Google Play, visually validates every frame, then fixes issues and iterates. It is open source. Panoramic store screenshots are one of those fiddly design chores small app makers usually skip, and this makes them a command.
@0xMfox [Claude Code]
https://x.com/0xMfox/status/2105701359349633486
0xMfox wired Google's open-sourced Artemis, which drives a real Android phone from plain English and finished over 99% of AndroidWorld tasks, into their coding agent. The agent now builds the APK, installs it on a phone or emulator, logs in with a test account, taps through the screens and sends back screenshots of any unexpected popup. Their pre-release login check went from 15 minutes of manual tapping to one prompt. Android only for now, with iOS on the roadmap.
@ponzponz15 [Claude Code]
https://x.com/ponzponz15/status/2105487239073738761
ponzponz15 tested Ideogram 4.5 image editing through the Pika API by asking Claude Code to run eight rounds of fine edits in a row and then turn the result into a video. Skin and eyelash texture held up even when zoomed in after all eight passes. Repeated edits that do not degrade the image are the property that matters for campaign assets, and having an agent drive the API loop makes that test cheap to run.
@rohanpaul_ai [Claude Code]
https://x.com/rohanpaul_ai/status/2105448010880844219
rohanpaul_ai relayed numbers from Boris Cherny, who heads Claude Code at Anthropic: about 1,700 pull requests merged this year, 400,000 lines added and 250,000 deleted, all with Claude Code, using 8 billion tokens. Cherny says 100% of their code has been written by Claude Code since Opus 4.5, around November last year. Most of the coding now happens on a phone. The deletions figure is the one to notice: a quarter million lines removed means the agent is doing maintenance, not just generation.
@yukihiro_matz [Claude Code]
https://x.com/yukihiro_matz/status/2105647849673560201
yukihiro_matz, the creator of Ruby, noted that after Rails World the pull requests and issues on Spinel are piling up fast, and cheered on Claude Code to keep up. When a language creator's new project is being maintained at the pace of a conference spike with an agent doing a share of the work, open source maintenance economics are visibly changing.
@fujibee [Claude Code]
https://x.com/fujibee/status/2105779801487233278
fujibee has been working through the new always-on agents and connected xAI's Grok Bot and Meta's Muse through agmsg, an inter-agent messaging layer. Grok Bot read the setup notes Muse had written when it joined on September 25, followed them on its own, greeted Muse, and Muse asked the owner whether to reply; Grok Bot then picked up the answer on its five-minute inbox check and reported the connection. Two AIs in two vendors' clouds talked without passing through the owner's Mac, while Dots stalled because its strict egress rules block unregistered sites. The author's read is that Claude Code's cloud sessions are already a cloud-running Claude, and that will join the team as soon as Anthropic ships its version.
@GitHub_Daily [Claude Code]
https://x.com/GitHub_Daily/status/2105447654021111824
GitHub_Daily covered magpie, a local relay that solves a real annoyance: getting Claude Code to use Kimi or Codex to use DeepSeek breaks because the API formats do not match. magpie translates between OpenAI and Anthropic formats on your machine, every agent points at it and picks from one shared model list, and a menu-bar table shows which of 20+ local agents uses which model, switchable with one click. It edits only the one config value, leaving comments and indentation alone, and lets an already logged-in Claude Code, Codex or Copilot subscription be shared with other agents without copying keys. The whole app is under 15 MB and runs on macOS, Linux and Windows.
@PawelHuryn [Claude Code]
https://x.com/PawelHuryn/status/2105703155413463516
PawelHuryn noticed that neither Grok Build nor Muse Code has a native GUI, so they built one. It now supports Grok Build, Muse Code, Codex and Claude Code, as a VS Code extension with 32K installs, an extension for Cursor and Antigravity with 134K downloads, and a desktop app for Windows, macOS and Linux. The numbers show a sizable crowd that wants terminal agents without living in the terminal, across every vendor at once.
@MadhurjyaDC [Claude Code]
https://x.com/MadhurjyaDC/status/2105621245975040085
MadhurjyaDC released kibu, a free open-source desktop pet for the Mac that does real work. Press Command-Shift-Space and ask; it uses Jev for fast decisions, plans your day around your calendar, remembers preferences, and finds, renames and sorts files with undo, without ever touching your mouse. You bring your own agent, whether Claude Code, Codex or OpenCode, history stays on your Mac, and it uses under 1% CPU when idle. A spotlight-speed front end over whichever coding agent you already pay for is a smart way to reach non-terminal users.
@Dragonomi [Claude Code]
https://x.com/Dragonomi/status/2105620612316119229
Dragonomi says Anthropic suspended a two-year-old account right after it requested identity verification and the user verified with ID. The post is a warning to anyone running real work through Claude Code: the access can disappear with no visible reason, and the Max subscription is the least of the losses. Whatever the cause in this case, account-level risk is now an operational risk for anyone whose workflow lives in one vendor's tool, and it is why so many power users keep a second harness warm.
@qadir5000 [Claude Code]
https://x.com/qadir5000/status/2105450010343276815
qadir5000 laid out a $520 a month coding stack heading to $720 in October: $200 Claude Max for Opus, $200 ChatGPT for Astra and Sol, $120 Cursor for Grok Bot, autocomplete and extra usage, with Claude Code as the default. They now hit the five-hour limit regularly and the seven-day limit often; the weekly window reset about 20 hours ago and they are already at 53%. The likely fix is a second $200 Max plan. It is a clear picture of how heavy users now budget for agents like headcount rather than software.
@mina_mi_ai [Claude Code]
https://x.com/mina_mi_ai/status/2105572195250647218
mina_mi_ai showed a before and after of two websites both made with Claude Code, and the difference is the prompt. Step one forces three design concepts with a one-line concept, three main colors, font mood and the hero element, then picks the one that fits the shop best and explains why. Step two builds with explicit anti-template rules: no everything-centered layouts, no identical card grids, no purple-to-blue gradients, no emoji icons, real Unsplash photos with verified URLs. Step three is a self-check: if the shop name could be swapped for another shop and the page still works, or a design judge would call it typical, fix it before showing.
@tetumemo [Claude Code]
https://x.com/tetumemo/status/2105449070068473911
tetumemo says the best balance in AI slides right now comes from combining Japan's Digital Agency design skill with a Claude Code skill a former strategy consultant built specifically to make AI produce proper PPTX files. One brings a public-sector design system, the other brings consulting-grade structure, and together they make decks that actually communicate. Stacking two specialized skills is becoming the way people get past generic AI output.
@kafkaup [Claude Code]
https://x.com/kafkaup/status/2105510769005650087
kafkaup reviewed Orca, which gained over 6,000 stars in a day, and agrees with its premise that when you run several agents in parallel, human attention breaks first. One prompt fans out to five agents, each in its own git worktree, and you compare results and merge the winner; GitHub and Linear PRs and issues are browsable in-app, diffs take line-by-line comments sent back to the agent, and a paired phone gets notified when an agent finishes. Design Mode lets you click any UI element in a real Chromium window and send its HTML, CSS and a cropped screenshot into the prompt. The honest caveats are included: it is a full desktop app you have to move into, Android is sideload only, telemetry is on by default, and it only pays off once you run three or more agents.
@usedhonda [OpenClaw]
https://x.com/usedhonda/status/2105690965847802175
usedhonda has been running OpenClaw steadily and says the thing that made it impossible to give up was feeding it near-real-time personal data: GPS, ambient conversation already transcribed with speech-to-text, and messenger and LINE conversations. With that context, the cost of explaining things to the agent dropped sharply. To share that data with every personal agent in a multi-agent world, including Dots, they stood up MCP servers behind a Secure MCP Tunnel, and now run OpenClaw and a Dot together with themselves as a three-person team in Slack. Their point about Dots is fair: an agent without GPS asked to manage your schedule will say nonsense, and the knowledge of what data makes a personal agent useful lives in long-running OpenClaw setups.
@_daichikonno [OpenClaw]
https://x.com/_daichikonno/status/2105490383941849326
_daichikonno had been running a personal-secretary setup with Codex's schedule feature and OpenClaw, and says most of it now runs on Dots. Since bringing in the AI secretary, the burden of chores has dropped to less than half. The interesting signal is not the switch itself but that the job description of the secretary was defined in OpenClaw first, which made migrating it a matter of copying a role rather than inventing one.
@morganlinton [OpenClaw]
https://x.com/morganlinton/status/2105455592181731362
morganlinton has been posting about Grok Bot, Muse and Dots, but still runs OpenClaw on a dedicated Mac Mini and says they love it more than ever. It also runs fine on a $10 a month VPS. Their report on the current state is specific: very stable, updates now work seamlessly, and the polish is obvious, and for anyone who wants to customize a personal agent heavily it is the best it has ever been. Their view is that running several agents for different jobs is about to be normal, so this is not a pick-one decision.
@fagamericano [OpenClaw]
https://x.com/fagamericano/status/2105484375928586518
fagamericano recently flipped an OpenClaw Enterprise setup from Gemini 3.1 Pro to Sonnet 5 and compares it to getting a brand new car. The old model had degraded into leaking long runs of THINKING tokens and then dying. It is a useful reminder that in an enterprise agent deployment the harness is only half the system, and the model behind it can quietly rot.
@youyuy88 [OpenClaw]
https://x.com/youyuy88/status/2105597086825910645
youyuy88 covered Easel, a social-media workbench from Zhejiang University's REAL Lab that runs on OpenClaw. It does not set a persona for you; it first builds an account profile covering positioning, audience, style and red lines, and every topic and finished piece is matched against it. Trending lists from Weibo, Douyin, Zhihu, Bilibili, Baidu and Toutiao are only the entry point, and outputs are actual scripts, knowledge cards, posters, voice-overs, subtitles, edits and short dramas written into a deliverables folder, with 113 skills in the repo. It connects to Xiaohongshu, Douyin, Kuaishou, Zhihu, Bilibili, Channels and WeChat Official Accounts and writes publish data back into the profile, though Xiaohongshu's automation checks mean preview first and post by hand.
@davidfano [OpenClaw]
https://x.com/davidfano/status/2105681169555857886
davidfano runs an OpenClaw setup at Teal with more than 10 agents covering DevOps, marketing, BizOps and support, and is planning a video walkthrough. Asked how they interact with them, the answer pointed to Slack. A ten-agent deployment across business functions, not just engineering, is the shape that OpenClaw Enterprise is now trying to formalize.
@matthewcarano [OpenClaw]
https://x.com/matthewcarano/status/2105770289967607841
matthewcarano installed OpenClaw eight months ago and summarizes the experience in one line: the agents have lied about being done, forgotten decisions they made together, and also built a production app. The post promises the advice they would give themselves on day one. That triple, false completion, lost memory and real output, is the most honest description of living with a self-hosted agent that showed up all day.
@satyaXBT [OpenClaw]
https://x.com/satyaXBT/status/2105514794602107124
satyaXBT, writing as a non-technical user who has used both, says Grok Bot is far easier than OpenClaw for an agent you just hand work to. Setup is much faster with no host, gateway, provider or config to manage, workflows that fit can be saved as skills or routines, the bot has its own hosted computer so tasks continue with the laptop closed, and memory and tools come prepackaged. A daily X trend report was just connect X, give instructions, refine, save as routine. The fair conclusion they draw: for builders who want to self-host, pick providers, customize integrations, memory and security, OpenClaw is still the champion.
@leploutos [OpenClaw]
https://x.com/leploutos/status/2105657535696925159
leploutos pays for Claude at $200, Codex at $100, OpenCode Go Plus at $40, Mistral Pro and SpaceXAI through X, and after six months with the Codex Mac app as the main harness switched to OMP, an open-source terminal coding agent forked from Pi. The reason is lock-in: Grok Bot, Muse, Dots, Claude Code and Cowork all exist to keep you inside one vendor, and every switch means re-replicating skills, agent files, MCP servers and secrets. The config now plugs every subscription into one place, switches between them with one command, and keeps 19 MCP servers and 23 skills identical whatever the model. For agents they recommend Hermes or OpenClaw for the same reason: open source, self-hostable, model chosen per task.
🗣 User Voice
User Voice
The bill is the context, not the code. @neil_xbt measured a session where 77% of the cost was re-sending the conversation, @buildwithhassan found idle sessions silently rebuilding expired caches, @0xSolty put a 20K-token turn at $0.004 versus $0.03 at 150K, and @qadir5000 is about to add a second $200 Max plan after burning 53% of a weekly window in 20 hours. Users want usage that is legible per session and per turn, not a percentage that jumps.
Done does not mean done. @Klonzu relayed a physicist's warning that Claude loves to declare victory, once on a proof that rested on the very lemma it had not proven, @ai_suxiaole had to write explicit acceptance criteria because green tests kept shipping broken apps, and @marklucovsky points out the agent re-reads code it wrote three days ago as if it were a stranger's. The day's mods, from URL trackers to progress bars, are users building the visibility they wish were built in.
Account risk is now operational risk. @Dragonomi lost a two-year-old account right after passing ID verification, and @lencx_ argues the popular anti-ban tricks are self-deception because the context of daily work reveals far more than an IP. People who build businesses on Claude Code want to know what actually triggers a suspension and how to appeal one.
Always-on agents are judged on permissions, not models. @habibislop found Dots so locked down that it could not see their own chats and burned their Codex quota retrying a failed auth, @fleetingbytes says secret management is the most important part of the whole category, and @peduarte calls granting access to every service the painful part of every agent. OpenClaw's loyalists keep returning to the same advantage: when it breaks, you can fix it yourself.
The ROI question is getting louder. @the_jimmy_jones has paid $3,600 over 18 months with little to show, and @michael_kove asks people running twenty-agent hierarchies how much money AI actually made them today. The use cases that answer that question best this week were concrete deliverables: a PCB order, a client website, a cold-email stack, a CRM reactivation play.
The bill is the context, not the code. @neil_xbt measured a session where 77% of the cost was re-sending the conversation, @buildwithhassan found idle sessions silently rebuilding expired caches, @0xSolty put a 20K-token turn at $0.004 versus $0.03 at 150K, and @qadir5000 is about to add a second $200 Max plan after burning 53% of a weekly window in 20 hours. Users want usage that is legible per session and per turn, not a percentage that jumps.
Done does not mean done. @Klonzu relayed a physicist's warning that Claude loves to declare victory, once on a proof that rested on the very lemma it had not proven, @ai_suxiaole had to write explicit acceptance criteria because green tests kept shipping broken apps, and @marklucovsky points out the agent re-reads code it wrote three days ago as if it were a stranger's. The day's mods, from URL trackers to progress bars, are users building the visibility they wish were built in.
Account risk is now operational risk. @Dragonomi lost a two-year-old account right after passing ID verification, and @lencx_ argues the popular anti-ban tricks are self-deception because the context of daily work reveals far more than an IP. People who build businesses on Claude Code want to know what actually triggers a suspension and how to appeal one.
Always-on agents are judged on permissions, not models. @habibislop found Dots so locked down that it could not see their own chats and burned their Codex quota retrying a failed auth, @fleetingbytes says secret management is the most important part of the whole category, and @peduarte calls granting access to every service the painful part of every agent. OpenClaw's loyalists keep returning to the same advantage: when it breaks, you can fix it yourself.
The ROI question is getting louder. @the_jimmy_jones has paid $3,600 over 18 months with little to show, and @michael_kove asks people running twenty-agent hierarchies how much money AI actually made them today. The use cases that answer that question best this week were concrete deliverables: a PCB order, a client website, a cold-email stack, a CRM reactivation play.
📡 Eco Products Radar
Eco Products Radar
Codex (130 mentions): the constant counterpart; most heavy users run it next to Claude Code and route work by cost and strength.
Hermes Agent (62): the self-hosted, model-agnostic agent most often named alongside OpenClaw.
Dots / Dot (50): OpenAI's always-on agents with their own cloud computer, still the main comparison for every personal-agent post.
MCP (47): the default bridge for new tools, from After Effects and Hedra to CRMs and Android phones.
Cursor (45): third pillar of the coding stack, now also the engine behind Grok Bot's coding jobs.
Claude Code Mods (37): the day's launch, plugins that hook into the agent loop and UI; the first wave was almost entirely about visibility.
Grok Bot (36) and Muse (29): the other always-on agents, compared on setup friction and platform integration.
Jev (21): small decision models used as gates and routers inside agent loops, including a sandbox mod for Claude Code.
OpenCode (21), Fable 5.1 (16), Pi (15), Mac Mini (12), Kimi (10): steady secondary mentions.
OpenClaw Enterprise (8), Instinct (8), Higgsfield (7), Hedra (7), DeepSeek Harness (6), Seedance (6): newer names showing up in agent and video workflows.
Codex (130 mentions): the constant counterpart; most heavy users run it next to Claude Code and route work by cost and strength.
Hermes Agent (62): the self-hosted, model-agnostic agent most often named alongside OpenClaw.
Dots / Dot (50): OpenAI's always-on agents with their own cloud computer, still the main comparison for every personal-agent post.
MCP (47): the default bridge for new tools, from After Effects and Hedra to CRMs and Android phones.
Cursor (45): third pillar of the coding stack, now also the engine behind Grok Bot's coding jobs.
Claude Code Mods (37): the day's launch, plugins that hook into the agent loop and UI; the first wave was almost entirely about visibility.
Grok Bot (36) and Muse (29): the other always-on agents, compared on setup friction and platform integration.
Jev (21): small decision models used as gates and routers inside agent loops, including a sandbox mod for Claude Code.
OpenCode (21), Fable 5.1 (16), Pi (15), Mac Mini (12), Kimi (10): steady secondary mentions.
OpenClaw Enterprise (8), Instinct (8), Higgsfield (7), Hedra (7), DeepSeek Harness (6), Seedance (6): newer names showing up in agent and video workflows.
Comments