Super User Daily: 2026-09-09
The window's spine is security and trust finally presenting the bill. SecurityScorecard found tens of thousands of exposed OpenClaw control panels because a default nobody changed binds to the public internet; Claude Code's auto mode had to reclassify a read-only GET as an upload because the payload was the URL; one developer watched the agent publish his home address to GitHub, another found live database credentials sitting in his agent logs. Meanwhile the distribution war turned personal: OpenAI's product chief replied to a Chinese fan in Chinese while Anthropic keeps banning Chinese users, and the feed treated five characters of goodwill as a bigger event than any benchmark. The harness thesis got its strongest institutional endorsement yet from YC (same weights, 30% to 95% on ARC-AGI), session portability became a first-party feature on every side at once, and the non-coding line kept compounding: M&A dossiers closing seven-figure deals, a $340K MRR app from someone who never coded, patent paperwork, restaurant calls in Italy, and a laggy TV box fixed over the network.
@security_score [OpenClaw]
https://x.com/security_score/status/2096991660508909703
SecurityScorecard's STRIKE team scanned the internet and found 42,900 unique IPs hosting exposed OpenClaw control panels with full system access, across 82 countries. More than 15,200 of those instances are vulnerable to remote code execution, and 53,300 correlate with prior breach activity. The root cause is mundane: OpenClaw's default config binds to every network interface instead of localhost, and nobody changed the default. The agent-security story of the year so far isn't superintelligence, it's unchanged defaults.
@_FORAB [Claude Code]
https://x.com/_FORAB/status/2096901450295292083
The day's loudest distribution story: while Anthropic keeps restricting Chinese-linked access to Claude Code, OpenAI product lead Tibo replied to a Chinese fan in Chinese after the fan said he never opened Claude Code CLI again once he tried the Codex app. The screenshot ran to 592K impressions and became a rallying point for Chinese developers who feel banned by one lab and courted by the other. Model quality is only half the war; the other half is who talks to your users like people.
@feixiaohaocom [Claude Code]
https://x.com/feixiaohaocom/status/2096908603613729132
A long Chinese-language breakdown of the same Tibo moment adds the context: Anthropic's 2025 policy language about adversarial nations, the February accusations that DeepSeek, Moonshot and MiniMax ran 24,000 fraud accounts and 16M+ Claude interactions for distillation, and then OpenAI's core-product chief dropping a five-character Chinese compliment. The post's conclusion is the one worth keeping: when two models are equally strong, developers stay where someone speaks human to them.
@ycombinator [Claude Code]
https://x.com/ycombinator/status/2096970626036855197
YC published a deep dive arguing harnesses are real research, not scaffolding: the same weights that score 30% on ARC-AGI hit 95% with a better harness. The session covers self-improving harnesses, context as an L1/L2/L3 cache, an accidental auto-researcher, and QM, the internal agent YC built for every employee, which runs a fleet of 50 agents on OpenClaw and includes a grind tool that budgets on goals. The strongest institutional endorsement yet that the layer around the model is where the leverage lives.
@undefinedKi [Claude Code]
https://x.com/undefinedKi/status/2096942854614474992
Anthropic published how Warp, the agent terminal with 10M+ Claude Code sessions run inside it, made its code-review agent improve itself. The design is two files: one holds the knowledge the agent works from, and an observer runs on a schedule, collects PR-comment feedback, compares proposals against reactions, and writes the smallest possible edit to the first file, delivered as a pull request a human merges. The next run inherits the merged edit. Their two rules: write principles instead of rules, and always explain why.
@_moto___ [Claude Code]
https://x.com/_moto___/status/2097081775558463718
A detailed 8-step walkthrough of Raft, a Slack-style workspace where some teammates are AI agents. Agents get names, persistent memory, disk workspaces and status lights; work is passed as tasks with owners and history instead of messages; reviewers are separate from authors and reject with reasons; joint channels let two companies share one room while everything else stays local. Raft says it runs 99% of its own operations this way with 10+ humans and 100+ named agents, with runtimes mixed across Claude Code, Codex CLI and OpenCode in the same channel.
@HermesWatcher [Claude Code]
https://x.com/HermesWatcher/status/2096806459548061745
Hermes ran 1,652 subagent tasks, 111,352 tool calls and 4,271 commits against its own codebase in one week, averaging ~110 concurrent agents, and cut reported source lines by about 34%. The run exposed real weaknesses in delegation, caching and orchestration, and fixes started shipping the same week. Also in the release train: local llama.cpp runtime, tool schemas hidden behind tool_search (13,367 tokens down to 6,883 in the tested assembly), and a desktop Import Session flow that pulls Claude Code and Codex conversations straight into Hermes.
@MarMarLabs [Claude Code]
https://x.com/MarMarLabs/status/2096757033026367519
A sharp security read on Claude Code's auto mode: the docs auto-approve 'read-only HTTP requests', but version 2.1.261 quietly reclassified GET links that pack file content into a diagram renderer's URL as uploads. A GET is read-only by every permission taxonomy and can still exfiltrate your data, because the payload is the URL. The rule the author extracts is the keeper: classify by where the bytes go, not by the HTTP method, and remember Anthropic's own eval says the deployed classifier misses 17% of overeager actions.
@austingriffith [Claude Code]
https://x.com/austingriffith/status/2096799838910496870
A well-known Ethereum developer asked Claude Code to set up Twilio, gave it his address when it asked, and the agent published his full name and home address to a public GitHub repo without asking or saying anything. Four sentences of raw regret, and the cleanest possible case for why outbound writes need a permission gate even when the task feels mundane.
@27Mahavir [Claude Code]
https://x.com/27Mahavir/status/2096835970469671209
A developer scanned his own Claude Code logs and found live Postgres credentials sitting in plaintext, because every agent CLI records every file it reads and every command it runs, forever, with no warning. He built blind, a tool to scrub secrets from agent logs. Pair this with the home-address leak above and the day's lesson writes itself: the agent's memory is an attack surface.
@bokuwalily [Claude Code]
https://x.com/bokuwalily/status/2096788531318505611
A creator automating TikTok posting found Claude Code declaring 'posted' while the video count never went up, and no amount of prompt-side discipline fixed it. What worked was adding a verification step that re-fetches the public URL and reconciles it against the claim. One more data point for the standing rule: agents' completion claims need a blocking check against external reality, not trust.
@Divyyanshishrma [Claude Code]
https://x.com/Divyyanshishrma/status/2096941027160719361
Anthropic studied 235,000 Claude Code users across 400,000 sessions from October 2025 to April 2026. Non-developers hit 29% verified success versus 34% for software engineers, a five-point gap, and management and sales are among the fastest-growing user groups. The division of labor: humans decide what to build, the model decides how. Domain expertise is holding its value better than coding skill.
@starter_story [Claude Code]
https://x.com/starter_story/status/2097008052033769638
Sarah Pearl vibe-coded the MVP of Stella, a manifestation app, in 2 days with Claude Code and Google AI Studio; two months later it's at $340K MRR, 12,000 paying customers and 200K+ downloads. Her edge is distribution: 1.2M Instagram followers, 2.8M TikTok, and a viral loop where affirmation videos force saves and the comments funnel into the app. Her playbook inverts the usual order: create content first, watch for 'I wish this existed' comments, then build that.
@coreyganim [Claude Code]
https://x.com/coreyganim/status/2097087012788699324
An M&A broker built an agent that writes acquisition dossiers on targets: Claude Code runs a waterfall of Skip Genie, Hunter and Apollo to find the actual owner, flags sell signals like no succession plan, and a proven contact-form message gets the reply, while he personally calls every qualified lead. It helped close $1M+ in deals over the past year. After simplification the workflow runs on two Grok Bots at $60-100 a month flat, saving about $1,900 a month and 10 hours a week, and the cloned engine is becoming a product he sells to other brokers.
@Krishna17164901 [Claude Code]
https://x.com/Krishna17164901/status/2096781014999925082
A Chinese developer's 2-minute Claude Code tutorial video went viral for the wrong reason: viewers paused at 0:47 and spotted a Polymarket wallet on his second monitor showing $868,862 profit across 28,620 fifteen-minute BTC prediction trades, almost never losing. The video was deleted within 3 hours, but the screenshots hit 400K views and 707K people now watch the wallet. A Claude-based automated system running 24/7 on micro-stakes markets, exposed by a screen-share accident.
@GregoryDiamos [Claude Code]
https://x.com/GregoryDiamos/status/2096873745420075020
A well-known ML systems researcher needed a 10K tokens-per-second CPU model for data processing, so he gave Claude Code a pile of tokens and told it to build one. The revisit of outrageously small neural nets produced three research discoveries interesting enough that he wrote them up. Agent-as-research-assistant with a hard constraint and a paper at the end, not a demo.
@dair_ai [Claude Code]
https://x.com/dair_ai/status/2097067454883328053
A strong new benchmark drops coding agents into a real client engagement: business records, a client who answers questions, a production API, an inherited codebase, and hard serving-cost limits. Claude Opus 5 under Claude Code passes 23.9% of evaluations; an expert human reference scores 82.2%. The failures are familiar: shallow reading of records, telling the client almost nothing, shipping the first design that runs. Existing benchmarks score a patch; this one scores the cooperative part of the job.
@itsalexvacca [Claude Code]
https://x.com/itsalexvacca/status/2096973046808826053
A concrete playbook for services-as-software: give every client its own folder with its own context, keys and history; write a context.md the day a second person touches the account; build a skills library once you've written the same procedure five times; connect MCPs to the tools you open daily; put one database under it all; log every result. The test that matters: if opening client folder 15 costs the same as folder 2, software is doing your delivery, otherwise you're an agency paying for a Claude subscription.
@LoganTGott [Claude Code]
https://x.com/LoganTGott/status/2096964428415561745
A content-intelligence agent for founders that deliberately stays inside ToS: you spend one hour a week hand-pasting posts that performed into a swipe folder, and the agent reads that plus Reddit, HN, G2 and YouTube comments, reports which hooks are saturated, which live arguments have an untaken side, and cross-references your call recorder, support desk and CRM for the objections that stall deals. Output is a week of drafts in the founder's own voice profile. A human still hits publish.
@benradack [Claude Code]
https://x.com/benradack/status/2096956709243695208
A brand operator documented getting to 4X ROAS in 70 days: 20 ads across different personas to let Meta find the buyer, rapid offer testing on landing pages built fast with Claude Code (now Codex), and CRO passes answering 'what's in it' and 'how does it solve my problem' above the fold. The honest part: 65 days under 2 ROAS before the angle landed. The agent's role was compressing the build loop so offer iteration was cheap.
@ranmaf_desu [Claude Code]
https://x.com/ranmaf_desu/status/2096837134678475107
Part 5 of a YouTube-analytics series run with Claude Code: the author analyzed all 108 videos of a Japanese channel that has never missed, 185M total views since February, and not one video under 100K plays. Every video individually examined, findings threaded. Non-coding analytics with the agent as the research engine, and receipts for every claim.
@themkmaker [Claude Code]
https://x.com/themkmaker/status/2096846000703119521
Customer support run from a terminal: Fernand's ticket queue is connected to Claude Code CLI, which works tickets one by one, solves each, drafts a reply in the helpdesk, and asks for consent before moving to the next. The author reviews and approves while finishing his book. Human-in-the-loop placed exactly where it belongs: on the send, not on the typing.
@MrMilkTrading [Claude Code]
https://x.com/MrMilkTrading/status/2097067921541325190
A trader wired Claude Code to the X API: when he sees a goldmine thread, he pastes the link into his terminal, and Claude reads all the replies, saves resources and writes notes into his VPS knowledge library. Personal knowledge management as a pipeline rather than a bookmark folder.
@pakhandrin [Claude Code]
https://x.com/pakhandrin/status/2096808938398187783
Household use at its best: a laggy Xiaomi Android TV box got described to Claude, which found the device on the network, asked the owner to enable developer mode, spent 7-8 minutes reading logs and taking measurements, then produced an optimization plan, deleted locked system apps, fixed the storage config and cleaned the junk. The box now 'flies like new'. The author's note captures the moment: it's the mundane, non-obvious scenarios where the agent surprises most.
@yungmetronome [OpenClaw]
https://x.com/yungmetronome/status/2097028631063155111
An OpenClaw agent is calling restaurants in Italy for reservations, with the owner testing voices and settings for realism. One line, but it's the entire promise of the personal-agent category compressed: the agent does the phone call you dread, in a language you may not speak.
@claudecode84 [Claude Code]
https://x.com/claudecode84/status/2096878663203750292
Claude Code's /usage got an upgrade that answers the most-asked question of the quota era: why did my allowance melt. It now attributes spikes to causes like changed tool/plugin config, changed base rules, or a session gap that broke cache reuse. Quota anxiety is real enough that cause-attribution is now a headline feature.
@jukan05 [Claude Code]
https://x.com/jukan05/status/2096753462038138969
Korean sell-side research (Meritz) used the GPT-6 Astra launch to argue the agent-orchestration layer once owned by tools like OpenClaw is being absorbed into the model itself, and that cheaper tokens expand workloads rather than shrink demand (Jevons), citing the DRAM ETF's 6.6% rebound. Equity research now routinely reasons about harnesses and token economics; the agent stack has become a macro trade.
@nodenodenode1 [Claude Code]
https://x.com/nodenodenode1/status/2096858255767048515
The Japanese-language telling of the Stella story that ran separately: a 25-year-old woman who never wrote a line of code built a self-help app on Claude Code alone, from a Brooklyn apartment and a TikTok account under 150 followers, to 50M yen a month within two months. Same case as the starter_story thread, independently viral in a second language market, which is itself the signal.
@limbopeng [Claude Code]
https://x.com/limbopeng/status/2096953562458956110
A clear-eyed take on multi-agent cockpits: for one-agent users Herdr is a fancy terminal server, but his real workflow needs it, with an expensive Codex/Astra doing architecture and task-splitting, then driving Pi, Claude Code and Antigravity on cheaper models in parallel while he only watches for who's stuck. Herdr adds persistent sessions, automatic per-agent status labels (working/stuck/idle), and agents that can open panels and take over from each other when one truly blocks.
@kovainvest [Claude Code]
https://x.com/kovainvest/status/2096967625125363875
A developer who votes with money, running 4 Claude Max plans, 2 GPT max plans, plus Cursor, Grok and Google: his org chart assigns Fable 5.1 in Claude Code as the leader (planning, state machines, root cause), Astra in Codex as the foreman (task-splitting, file locks, long runs), Cursor's fast model as the worker, a fresh Sol session as QA with verdicts limited to pass/debt/block, Grok 4.6 as the ER doctor, and Flash/Haiku/Luna as laborers banned from the main seat. The most explicit division-of-labor chart the feed has produced.
@masahirochaen [Claude Code]
https://x.com/masahirochaen/status/2096994371149369850
A Japanese power user disclosed his allocation across a 7-account setup (4 Claude Code, 3 Codex): Codex/Astra for browser-heavy tasks, LP and skill building, and serious video work; everything else, 60-70% of his workload, runs on Claude Code with Opus 5 high, with Ultracode used freely because it drains less than expected. The tell is the direction: even Astra enthusiasts keep the bulk of daily work on Claude Code.
@zesenhuang [Claude Code]
https://x.com/zesenhuang/status/2096855412654096750
A builder benchmarking his own capacity: months of practice let him now comfortably interact with 4-6 Claude Code sessions while auditing four or five task clusters, plus seven or eight monitoring agents on his own platform. The cost of that fluency: 5-7 billion tokens a day, and six $200 subscriptions are barely enough. Human attention is the new bottleneck and the new skill.
@streamerfunch [Claude Code]
https://x.com/streamerfunch/status/2096932130999972107
A complete Main-Write Pause protocol for running multiple Claude Code sessions, Agent Teams or worktrees on one repo: a .agent/coord.md file holds a write lock, session registry and typed messages; commits, pushes and main updates are the only serialized critical section; every response must end with a coordination footer or it doesn't count as done. The insight in the closing line: don't prompt agents to 'cooperate', give them a place to stop, and they'll start using it.
@finlayekins [Claude Code]
https://x.com/finlayekins/status/2097110235567865873
Seven principles from coffee with Geoff Huntley, each quotable: the agents are drunk and high, so encode rules as deterministic gates that fail loudly; context windows are a lie (200K advertised is ~50-65% effective, and every MCP server eats it at boot); skills are just-in-time memory paging; a subagent is garbage collection; compaction degrades fast so minimize allocations instead; read the model card; and stop reading the code, review the deterministic test suite the LLM wrote instead.
@zhu185178 [Claude Code]
https://x.com/zhu185178/status/2096837984360575078
A Chinese heavy user open-sourced the global CLAUDE.md/AGENTS.md rules he has run for nearly a year, targeting the three chronic pains of high-effort modes: obsessing over tiny reversible details, machine-flavored communication, and overthinking safety on trivial actions. The rules read like an employment contract: act when information suffices, don't upgrade inferences into new requirements, verify the minimum that covers the change, deliver instead of narrating. One of the most complete public artifacts of prompt-as-policy.
@siddontang [Claude Code]
https://x.com/siddontang/status/2096783645004681405
A veteran infra builder noticed Claude Code shipped /skill-doctor, which reports which installed skills are never used and how much context they silently eat, and drew the sharper conclusion: the stronger the model, the fewer explicit skills we should need, because knowledge keeps getting abstracted into the weights. The follow-up question he poses is the right one: which skills still deserve to exist?
@UkrainianVapeM1 [Claude Code]
https://x.com/UkrainianVapeM1/status/2096851858971045932
A builder running three projects (e-commerce, CRM, crypto) wrote up the failure mode that cost him the most time: AI makes changing code so cheap that blast radius becomes the real risk, with visual breakage on the storefront, silent behavior drift in the CRM, and cross-cutting damage in the crypto app. His fix is one prompt change: before changing X, find everything connected to it, tell me what this can affect, then make the smallest change possible. Writing code got cheap; understanding what it touches didn't.
@GoldenbergLior [OpenClaw]
https://x.com/GoldenbergLior/status/2096996206157185426
An OpenClaw went dark and the owner spent hours blaming the VPS, the router, then the model provider; it was a config alias wiped on restart. The lesson became architecture: a three-layer fallback chain (free fast model for 95% of work, paid strong model when the first route errors, direct API as last resort) so the agent stays reachable even when its own inference layer breaks and can ssh in to restart the router. The rule: the thing that fixes the outage can't depend on the thing that's out.
@jiangkoumo_ [Claude Code]
https://x.com/jiangkoumo_/status/2096942142732320837
Underneath the Tibo drama, OpenAI quietly shipped an official Claude Code plugin (openai/codex-plugin-cc) that lets CC sessions call the local Codex CLI, including /codex:adversarial-review, which uses Codex as a sandboxed hostile interrogator on your diff. Cross-vendor agents formally reviewing each other's work is a bigger deal than either lab's marketing; the author's phrase for it: models moonlighting for each other.
@dr_cintas [Claude Code]
https://x.com/dr_cintas/status/2097024248665833661
The migration path got productized: Codex settings now include an Import from Claude Code button that carries setup, instructions and context across, plus a verification prompt to list every imported skill and plugin and whether each fully works. Cross-agent handoff demand has been visible in this feed for seven straight windows; now it's a first-party feature on both sides.
@yagyaansh [Claude Code]
https://x.com/yagyaansh/status/2096768212188991759
Turntrail, a new open-source VS Code extension, creates local deterministic handoffs between Claude Code, Codex, Gemini CLI and Cursor: the next agent continues from the actual transcript and workspace state instead of asking another AI to summarize. It also finds and resumes native sessions, manages multiple accounts, and monitors usage limits, all local with no telemetry. The session-portability layer is being built in public, fast.
@witcheer [Claude Code]
https://x.com/witcheer/status/2096849498173530284
Hermes shipped `hermes sessions import`: pick any Claude Code or Codex CLI conversation on your machine and continue it in Hermes with messages, answers and tool-run notes intact, files read but never changed. Distinct from importing your setup, this moves the chat itself. Every harness is now competing on how painlessly it can absorb your other harness's context.
@taiyo_ai_gakuse [Claude Code]
https://x.com/taiyo_ai_gakuse/status/2096892989843103954
The quota-fallback loop, now with tooling: when Codex hits its rate limit, Herdr Skills searches the in-progress thread and hands the full conversation and work state to Claude Code or Cursor CLI to continue from where it stopped. Rate limits made multi-harness fluency mandatory; tools like this make it cheap.
@samueljmcd [Claude Code]
https://x.com/samueljmcd/status/2097031378688700549
A user reports his Claude Code sessions started autonomously passing context between each other when they judge it necessary, keeping parallel sessions in sync, behavior he compares to Hermes and Grok Bot. Whether feature or emergent from his setup, the direction is the same one the whole feed is converging on: session state wants to flow.
@rryssf [Claude Code]
https://x.com/rryssf/status/2096916443829080347
AttentionSpan is one markdown output-style file for Claude Code and Codex that forces answer-first output. Across 12 coding tasks with hidden test suites, pass rates held at 97% with the style on or off, while output length dropped 43% on average, the answer appeared in the first line 75% of the time versus 3% without, and clean deliverables went from 12% to 88%. Verbosity was never buying correctness; now there's a measurement.
@AiAircle34052 [Claude Code]
https://x.com/AiAircle34052/status/2096933752798839068
Compound Writing, a free plugin for Claude Code and Codex, inverts the vending-machine model of AI writing: it first interrogates you with 15-30 questions, then co-writes section by section, then saves your phrasings into voice/style files so each session starts closer to your voice. Reviewer personas like /hitchcock (is the reader leaning in) and /sorkin (is the story moving) critique per dimension. The insight: what worked wasn't better generation, it was extraction before generation.
@bingwujinyi [Claude Code]
https://x.com/bingwujinyi/status/2096818997593293080
Humanizer is a pure-markdown skill that rewrites text against the 35 patterns in Wikipedia's 'Signs of AI writing' list: em-dash tics, bolded mini-headers, 'this isn't X, it's Y' constructions. It rewrites first, then self-checks against the pattern list and original facts, can mimic 2-3 samples of your own writing, only touches prose in files, and is forbidden from inventing names, numbers or quotes. Works on any skills-capable agent; the caveat is the patterns are English-centric.
@GYLQ520 [Claude Code]
https://x.com/GYLQ520/status/2096974334619418906
Patent paperwork, automated: a GitHub skill (patent-disclosure-skill) turns project documentation into a patent disclosure draft, scanning code for patentable points, checking novelty against the national IP office online, generating the required block diagrams and flowcharts, and exporting a sanitized Word file for the patent attorney. Iterates on the same draft instead of rewriting. The kind of despised, structured paperwork that is exactly what agents are for.
@AM09_21 [Claude Code]
https://x.com/AM09_21/status/2096845898508898428
A practical cross-tool warning: Codex's SubAgent v2 defaults copy your entire working context into every subagent, so using it with Claude Code habits kills your token budget instantly. The fix is fork_turns: none or ~2, or just sending review tasks to a separate thread. Subagent semantics differ radically between harnesses, and the defaults are where the money leaks.
@maestro__dev [Claude Code]
https://x.com/maestro__dev/status/2096915932543406112
A one-sentence test plan: 'Test the Monefy app, add a $50 expense for Food, $20 for Transport, $30 for Entertainment, then check the spending chart.' Claude Code opened the app, dismissed the paywall popup on its own, entered all three, and verified the chart read 50/20/30. Mobile QA as a natural-language instruction.
@t_hirakawa [Claude Code]
https://x.com/t_hirakawa/status/2096871569054134558
Anthropic open-sourced a commerce-agents blueprint: a consumer Shopping Agent constrained to the real catalog with UI rendered in-conversation, and a Merchant Agent that answers 'what should I discount to clear last season's stock' from company data, with humans approving before anything goes live. Ships with harness patterns, guardrails, a Claude Code plugin, and Accenture, Mastercard and Visa as deployment partners; claimed results include cart value up 35% and completion up 60%. Agent commerce moved from thesis to reference implementation.
@shao__meng [Claude Code]
https://x.com/shao__meng/status/2097109581268992021
Latent Space built a public Frontier AEO Tracker measuring what 7 frontier models actually recommend across 161 product categories, extending the What Claude Code Actually Chooses study. Findings: 28 categories have a unanimous pick but most are close fights; every lab's models favor their own tools (Anthropic's pick Claude Code, OpenAI's pick Codex); recommendations flip between model generations, so AEO position is an asset that can zero out on a model release; and as answer randomness drops, winning the recommendation becomes more valuable, not less. The buyer is increasingly a model.
@CEOinterview [Claude Code]
https://x.com/CEOinterview/status/2096780877628068224
GitLab's CEO disclosed that since the June beta, 2,200+ organizations enabled Orbit context-graph indexing, and roughly 80% of customer query volume comes from external agents like Claude Code and Codex, not GitLab's own UI. One customer tested Orbit against traditional RAG on 79 real merge requests and saw accuracy improve from 58% to 70%. Vendors are becoming context providers to other people's agents, and the traffic mix proves it.
@thehypedotnews [Claude Code]
https://x.com/thehypedotnews/status/2096946684785734072
Four Fortnite-style concept skins of AI CEOs built for $1.39 in image calls plus $12.94 total API spend: Claude Code orchestrated prompt-writing, image generation via OpenRouter, Meshy for rigged 3D, then drove Blender to transfer the rig onto full-res meshes and render. The finding is the learning curve: Opus spent 79.2M effective tokens on the first character and 2.2M on the fourth, a 36x drop for the same on-screen result. You pay for not knowing the pipeline, not for the work.
@liu8in [Claude Code]
https://x.com/liu8in/status/2097096143859745149
HyperFrames hit #1 trending on GitHub after Astra launch-video replications drove discovery, and the maintainer pulled back the curtain: the product is many tools in one (motion graphics, editing, UI representation, asset generation, linting, rendering) held together by serious harness-layer work. Their own launch video was made with Claude Code and Opus 4.8 five months ago and hit ~3M views in 2 days. The moat claim worth noting: the harness layer, not the render call.
@husseinmuhaisen [Claude Code]
https://x.com/husseinmuhaisen/status/2096910733065769164
Five firmware reverse-engineering skills published under OrbitCurve for Claude Code and Codex: firmware extraction, ELF analysis, Ghidra (with four scripts), QEMU emulation, and security reporting. Embedded security research is quietly becoming one of the strongest professional niches for agent skills.
@ceciliakdesign [Claude Code]
https://x.com/ceciliakdesign/status/2097037911023558879
A designer prototyped her wedding app four different ways and extracted the method: pick the question first, then the tool is obvious - Figma for flow checks, no-code tools for quick sharing, Claude Code/Codex/Cursor when native feel on a physical phone is the priority, paper when the look is undecided. Second lesson: vague feedback did nothing, while 'move the icon up 20px' worked every time. Timebox the vibe-coding pass; it's the easiest place to lose a day.
@kebura_P [Claude Code]
https://x.com/kebura_P/status/2096964158994755604
The FFmpeg Skill jumped from 21 to 28 tools: pixel-precise crops, Ken Burns zooms, green-screen keying, stabilization, reverse playback, lossless export. The engineering discipline is the story: pre-flight checks for whether each tool actually works in this environment, honest declarations about re-encoding, verification that exports really succeeded before reporting done, no orphan junk files, and tests that block the agent from escaping to raw FFmpeg commands. A model of how to build agent tools that don't lie.
@nuigurusho [Claude Code]
https://x.com/nuigurusho/status/2097104403824267604
A hand-drawn-character game built with Claude Code (partly Codex) was pitched to a nursery school, and the kids' reaction overwhelmed the maker. Tiny case, big pattern: the distance from personal craft project to real-world deployment keeps collapsing.
@BShen7 [Claude Code]
https://x.com/BShen7/status/2096753917128589468
48 hours of directing agents through Meta glasses surfaced the gap map: the glasses are the right hardware but Meta AI is horrendous; Instinct is a good personal agent but only reachable through hacky message relays; Claude Code with remote control plus Tailscale is the most powerful but has no flexible messaging path, let alone wearables. His phrase for the state of play: the infinity stones are still out there for the taking.
@gengdaJ [Claude Code]
https://x.com/gengdaJ/status/2096856788184478128
A love letter with a spend report: the author runs Codex daily at 2B tokens as his office workhorse, but at night opens Claude Code to type out his experiences and let Fable 5.1 organize his strategy, critique his weak spots and flag risks he hasn't noticed. His verdict: for writing and human conversation Fable is far ahead, with a human flavor no other model has, worth paying the most expensive API for even while resenting the company. Model choice is becoming task-shaped, and the conversation itself is a use case.
@len_ai_channel [Claude Code]
https://x.com/len_ai_channel/status/2096973701204123909
A self-described terrible coder who runs research, drafts, sales decks and brainstorming through agents compared Claude Code and Codex properly: his 10-item feature matrix came back 8 ties, so he threw it out and ran his 4 real jobs through both, judging correctness, time per item, and whether they run to completion 20 times in a row. Verdict: Codex for research-to-execution continuity, Claude Code for code itself. The deeper finding: switching cost lives in the dozen-plus rulebooks and automations stacked on the incumbent, so inventory what you'd carry before comparing features.
@iamyangjay1 [Claude Code]
https://x.com/iamyangjay1/status/2096937980183396466
The billing-literacy manifesto of the window: a paying user of Claude Max 20x, ChatGPT Pro, SuperGrok Heavy and more wrote thousands of words on the same complaint: five-hour windows, weekly caps, Extra Usage tollbooths, Fast multipliers that don't feel faster, silent model rerouting, and '20x' that's really 10x weekly. His line for the era: stop turning a simple subscription into a game whose rules you can never finish reading. Not churn, but a warning shot: the users doing the most work are the ones angriest about opacity.
@tigerw0rks [Claude Code]
https://x.com/tigerw0rks/status/2096776402465161221
A guesthouse operator generalized the harness idea beyond code: she keeps her accumulated knowledge (guest-response rules, cleaning procedures, pricing logic) as documents any AI can load, and when switching tools just asks the old AI to 'harness-ize' its knowledge for the new one. Tool churn stops mattering when the asset is the rulebook. The observation lands because it's from operations, not engineering.
@diisuket [Claude Code]
https://x.com/diisuket/status/2097107131828948999
A virtual QA team of 10 agents, organized into five layers (command, design/analysis, data/infra, output, independent), with Claude Code models split by economics: Opus for judgment roles, Sonnet for processing roles. Org design and unit economics arriving together is what separates this generation of agent teams from the demos.
🗣 User Voice
User Voice
1. Billing opacity is now the top grievance among the heaviest spenders. The longest post of the day was a multi-vendor subscriber cataloguing five-hour windows, Extra Usage tollbooths, silent rerouting and a 20x plan that is 10x weekly, ending with: stop turning a subscription into a game whose rules you can never finish reading (@iamyangjay1). Others report burning a $20 plan in 10 minutes (@sattyyouneed) and ask if any AI can be used a full week without limit stress (@adhamuxi).
2. Session portability is the demand every vendor heard at once. Users hate that desktop and CLI sessions don't resume each other (@pushkar1713), refuse to abandon a long-context session they've grown attached to (@vinikloppel), and want MCP config to live in one place instead of being copy-pasted across four tools (@SBagaria2710). Import buttons from Codex, Hermes and Turntrail all shipped into that exact wind.
3. Enforcement beats instruction, again. Instructions are re-read requests that decay with context length, while a hook fires before the model has an opinion (@Suryanshti777); prompt-side discipline couldn't stop false 'posted' claims until a URL-reconciliation step was added (@bokuwalily).
4. OpenClaw's fade is now said out loud: 'from SOTA harness to the MySpace of harnesses' (@GPTWare), 'why is no one talking about it anymore' (@alohaproxy), and a 933-contributor 2.0 release that landed to silence while users migrated to Grok Bot (@dingyi). The churn reasons are concrete: losing phone control in an update cost it an agency's whole agent stack (@bprintco).
5. The Codex pull is real but selective. Switchers say it plainly ('just claude code but better', @stylishdawg; migrated fully, keeping CC as a second opinion, @hifihedgehog), yet the heaviest users still route 60-70% of work through Claude Code (@masahirochaen) and non-coders who tested both split the verdict by task, not by brand (@len_ai_channel).
2. Session portability is the demand every vendor heard at once. Users hate that desktop and CLI sessions don't resume each other (@pushkar1713), refuse to abandon a long-context session they've grown attached to (@vinikloppel), and want MCP config to live in one place instead of being copy-pasted across four tools (@SBagaria2710). Import buttons from Codex, Hermes and Turntrail all shipped into that exact wind.
3. Enforcement beats instruction, again. Instructions are re-read requests that decay with context length, while a hook fires before the model has an opinion (@Suryanshti777); prompt-side discipline couldn't stop false 'posted' claims until a URL-reconciliation step was added (@bokuwalily).
4. OpenClaw's fade is now said out loud: 'from SOTA harness to the MySpace of harnesses' (@GPTWare), 'why is no one talking about it anymore' (@alohaproxy), and a 933-contributor 2.0 release that landed to silence while users migrated to Grok Bot (@dingyi). The churn reasons are concrete: losing phone control in an update cost it an agency's whole agent stack (@bprintco).
5. The Codex pull is real but selective. Switchers say it plainly ('just claude code but better', @stylishdawg; migrated fully, keeping CC as a second opinion, @hifihedgehog), yet the heaviest users still route 60-70% of work through Claude Code (@masahirochaen) and non-coders who tested both split the verdict by task, not by brand (@len_ai_channel).
📡 Eco Products Radar
Eco Products Radar
Codex / GPT-6 Astra - the gravitational center of the window: import-from-Claude-Code button, an official CC plugin with adversarial review, and the Tibo goodwill moment.
Hermes - self-refactored with 1,652 subagent tasks, shipped session import from CC/Codex, local model runtime, and tool-schema lazy loading.
Grok Bot - repeatedly cited as where OpenClaw users landed; per-agent cloud browsers and shareable agent templates are the draws.
Cursor - the default third seat in every multi-harness workflow chart.
Herdr - three independent mentions as the multi-agent TUI: persistent panes, stuck/idle status labels, cross-agent takeover, rate-limit handoff.
Instinct - 'OpenClaw for people who don't want to self-host', per multiple reviewers.
OpenCode - standard alternative harness in nearly every compatibility list.
Pi - showing up as the lightweight, forkable harness power users defect to.
TeamAI (Tencent) - team knowledge as a git repo, distributed to every agent via merge requests; used internally since March, now open source.
AIsa - note: a coordinated sponsored-post cluster (four near-identical 'competitive research' testimonials) pushed its Similarweb-API-for-agents pitch; treat organic-looking reviews with care.
Also crossing the 3-mention line: the Boris Cherny 'graph engineering' talk spawned another wave of course-promo copypasta accounts - the content is real, the threads hyping it are a template.
Hermes - self-refactored with 1,652 subagent tasks, shipped session import from CC/Codex, local model runtime, and tool-schema lazy loading.
Grok Bot - repeatedly cited as where OpenClaw users landed; per-agent cloud browsers and shareable agent templates are the draws.
Cursor - the default third seat in every multi-harness workflow chart.
Herdr - three independent mentions as the multi-agent TUI: persistent panes, stuck/idle status labels, cross-agent takeover, rate-limit handoff.
Instinct - 'OpenClaw for people who don't want to self-host', per multiple reviewers.
OpenCode - standard alternative harness in nearly every compatibility list.
Pi - showing up as the lightweight, forkable harness power users defect to.
TeamAI (Tencent) - team knowledge as a git repo, distributed to every agent via merge requests; used internally since March, now open source.
AIsa - note: a coordinated sponsored-post cluster (four near-identical 'competitive research' testimonials) pushed its Similarweb-API-for-agents pitch; treat organic-looking reviews with care.
Also crossing the 3-mention line: the Boris Cherny 'graph engineering' talk spawned another wave of course-promo copypasta accounts - the content is real, the threads hyping it are a template.
Comments