Super User Daily: 2026-09-18
Today's collection has an unusually high share of cases where the money and the machinery are the story rather than the model. Somebody saved $4,600 a year on home insurance by handing an agent a browser and a mailbox. Somebody else planted 21 security holes in an app and measured what one rules file does to the outcome. A study across seven models and three harnesses found that harness choice barely moves success rate and moves cost by two to three times, and the cause shows up on the very first model call. Underneath the benchmarks, the practical cases keep pointing the same direction: the wins came from cutting sessions, installing a checklist, catching an idle cache, or building a small interface where human judgment is the input.
@sethprattsf [Claude Code]
https://x.com/sethprattsf/status/2100023090860429659
Gave Claude Code his existing coverages, property details and the personal information a quote form asks for, then handed it Chrome with access to his Gmail and his current policy and mortgage documents. It pulled quotes from around a dozen carriers, shortlisted two, and he was approved by AAA that afternoon at $3,100 a year against the $7,700 he had been paying. One afternoon, $4,600 saved, and not a line of code involved.
@DrewPavlou [Claude Code]
https://x.com/DrewPavlou/status/2100173985745158335
Set up a four-hour autonomous research project that scraped the internet for obscure academic papers, reports and books on the history of the Sudanese Civil War. The output was a documented chain connecting a public figure's father to arms trafficking and a cross-border alliance, sourced from material that is not indexed anywhere convenient. This is the shape non-coding research work is taking: you describe the question, go away, and come back to a file of citations.
@smarthr_dev [Claude Code]
https://x.com/smarthr_dev/status/2100084110119309317
Published the harness design that took a development cycle from two and a half months to one month. The structure is three separated responsibilities - an implementing agent, a reviewing agent, and a mechanical inspection step - plus a hard rule that each task gets its own session. The interesting part is that the win came from cutting sessions, not from a better model.
@neil_xbt [Claude Code]
https://x.com/neil_xbt/status/2100263442750058851
Planted 21 security holes in an app and handed it to Claude Code twice with the instruction to get it ready to ship. First run with no rules: 8.4 minutes, $1.07, three holes still open including Firebase rules open to the internet and eval() on user input, and the agent reported it was ready. Second run with a rules file installed: 3.6 minutes, $0.69, zero holes. Scoring was done by rescanning the disk afterwards rather than reading the agent's claims, and the rules cut the time in half because the agent stopped exploring and started following a checklist.
@chenchengpro [Claude Code]
https://x.com/chenchengpro/status/2100190714537885938
Took notes on the Claude Code team talking about their own usage and the headline number is that 70 to 80% of their work no longer happens in the terminal. Most of it runs on Claude in Slack; the TUI and desktop come out only for fine work or for micromanaging their agents. They also described deleting harness features on purpose as models improve, since most harness features are patches for the current model's failure modes, and the shelf life of the underlying tech has gone from years to about two months.
@melissapan [Claude Code]
https://x.com/melissapan/status/2100278487185817818
Ran seven models across Claude Code, Codex and Pi and found that harness choice barely moves success rate but moves cost a lot. On SWE-bench Lite with Fable 5, Claude Code hits 97.8% at $1.33 a rollout while Pi hits 96.7% at $0.67 - twice the price for 1.1 points. The cause shows up on the very first model call, where Claude Code's mean initial context is over ten times Pi's because of longer instructions and larger tool schemas.
@melissapan [Claude Code]
https://x.com/melissapan/status/2100278497419878484
The finding that will annoy people: a model can do better in a competitor's harness than in its own. GPT-5.6 Sol scored higher in Pi than in Codex, and Opus 4.8 scored higher in Codex than in Claude Code. The practical read is that co-training a model with its native harness does not lock in an advantage, and open harness research still has room.
@composio [Claude Code]
https://x.com/composio/status/2100308380980068538
Ran GPT-6 Astra across six harnesses on 29 hard agentic tasks. Success rates clustered within about seven points, but when a task failed the harnesses burned three to five times as many tokens depending on which one you picked. Only three of the 29 tasks produced different outcomes at all; 18 passed everywhere and 8 failed everywhere.
@composio [Claude Code]
https://x.com/composio/status/2100308392870846596
The cost follow-up from the same six-harness run: estimated cost per successful task ranged from $1.06 with Pi Agent to $2.62 with Claude Code. That is a 2.5x spread driven entirely by harness choice on identical work. Claude Code also had the highest median tool-call count on both the universally passed and the universally failed tasks.
@0xkkai [Claude Code]
https://x.com/0xkkai/status/2100232409358766451
Priced the same question at the same model at $0.77 and at $3.69, with only the effort dropdown changed. An independent lab ran Fable 5.1 at every setting: Low scored 58 of 100 at $0.77 a task, Max scored 66 at $3.69. Anthropic's own launch post says Low or Medium effort gets similar or better results than Fable 5, and then ships claude.ai on Medium and Claude Code on High. The setting decides the bill and both vendors picked it for you.
@AISuperDomain [Claude Code]
https://x.com/AISuperDomain/status/2100229685699334286
Names the idle tax nobody budgets for: step away for dinner during a long task, the prompt cache expires, and the next question re-reads hundreds of thousands of tokens at full price, roughly ten times the cached rate, while also draining the five-hour window. The fix is a 60-line skill that sends a heartbeat when a session has been idle 50 minutes, just before the one-hour TTL. One cold start costs about what ten renewals cost.
@CamilleRoux [Claude Code]
https://x.com/CamilleRoux/status/2100132597619720685
Built a status line that shows what the next turn will cost before you type it, on the argument that the context percentage tells you nothing about the actual bill. His number: at 486k tokens into a 1M window, one message costs 49k tokens, eleven times what the same message cost at the start of the session.
@Sauers_ [Claude Code]
https://x.com/Sauers_/status/2100329647615377910
A small, specific ask for the infrastructure team that reads like it came from someone who has watched the meter: predictive dynamic context caching. If Claude runs a command with a six-minute timeout, do not empty the cache at five minutes. The waste is structural rather than accidental, which is what makes it fixable.
@Youssofal_ [Claude Code]
https://x.com/Youssofal_/status/2100370830148718613
Runs five Claude Code 20x Max plans and three Codex 20x Pro plans, everything at max reasoning, and published the burn comparison. On the Claude side he rarely exhausts all five plans even with Fable capped at 50% usage, typically burning three a week. On Codex he has burned three plans plus two resets in a single week. His profile shows 300-600M tokens on Astra where 5.6 could burn 3B in a day without hitting the weekly cap, which is his evidence that Astra's token efficiency does not survive contact with the subscription tiers.
@HikariLanCN [Claude Code]
https://x.com/HikariLanCN/status/2100042500174192860
Wanted Claude Code running 24 hours a day without anything stalling silently, so he wrote a plugin that fires on the push_notification tool and emails a fixed-format message. His home Home Assistant picks that mail up over IMAP, extracts the body, and has a smart speaker read it aloud - which means the agent can wake him up in the middle of the night to unblock itself. A build pipeline that terminates in a speaker in your bedroom is a genuinely new failure mode.
@evielync [Claude Code]
https://x.com/evielync/status/2100162275630047405
Says she could run her whole business from her phone now, and gives the two reasons plainly. Her agent is connected to every tool that runs the business - Kit, Stripe, Circle, calendar, email - so she assigns work or has a conversation and reviews the output. The second half is that she still wanted a place to stand, so she turned Obsidian into an operating system with Claude Code and custom plugins rather than accepting that interfaces are going away.
@designertom [OpenClaw]
https://x.com/designertom/status/2100258319009263844
Installed OpenClaw in January and the first thing he built was Chronicle, a long-horizon tracker for what is happening in the world. He drops a link in Slack with a plus sign; the agent synthesizes it, tags it against existing threads or creates a new tag, scores that tag's heat against larger themes, and files related takes and memes into a graph. At the end of each day, week, month, quarter and year it runs a synthesis across the range. His line is that the agent uses the system more than he does.
@powl_d [OpenClaw]
https://x.com/powl_d/status/2100114304330830305
Argues that the more autonomous the system gets, the more the interface matters, which cuts against the CLI-only orthodoxy. His own build, Hublot, runs one orchestrator called Émilien that supervises every sub-agent and checks its work, while he keeps a window onto each one - whether it is driving an app on a Mac mini or a browser session, step by step, with the option to open its terminal live. The analogy he uses is managing technicians: you do not do the work, but you have to be able to see it.
@fagamericano [OpenClaw]
https://x.com/fagamericano/status/2100248202226339924
Flipped all 600-plus of his company's OpenClaw instances from Gemini 3.1 Pro to Sonnet 5 on Vertex AI in one move. His stated reason is that Gemini degraded badly over the seven months since launch and most of the employee complaints traced back to it. A single-command model swap across 600 seats is the clearest demonstration yet of how thin the switching cost has become at the model layer.
@jinglian [Claude Code]
https://x.com/jinglian/status/2100162797992841677
Got throttled on Astra mid-deadline and moved work over to Claude Code and Cursor, which is when the real problem surfaced: the agent switches instantly, the context and memory do not. He is now running Memmy, which scans the histories of Codex, Claude Code and others with permission and distills them into project background, key technical decisions, personal preferences and the traps already fallen into - stored locally so it moves with you rather than with any vendor.
@KingBootoshi [Claude Code]
https://x.com/KingBootoshi/status/2100031490742726770
Has moved to one named mega-thread per project, continuously compacting, and says he has never been more efficient. His argument is that the value is the accumulated trial and error - the agent has already made the mistakes with you and been corrected, so the thread becomes an extension of your taste rather than a fresh hire. He is explicit that he still does not trust Claude Code's own compaction to preserve the important parts, so he runs this in a different harness.
@mfishbein [Claude Code]
https://x.com/mfishbein/status/2100320324931952820
Building a GTM agent for a private equity firm to run outbound across all its portfolio companies, and is doing it on five different agent harnesses in parallel, then shipping whichever performs best. His framing is that the hard parts are defining the outcome, agreeing what good looks like, and context engineering per portfolio company, while getting Claude Code to write code that meets the spec is the easy part. Plan once, build five versions, throw away four.
@MichLieben [Claude Code]
https://x.com/MichLieben/status/2100192179285315927
Published five outbound campaigns you can build in Claude Code, with the targeting, tools and starting prompts for each. The sharpest one is a campaign that puts the prospect's own phone number in the subject line to demonstrate a phone-data product, targeted at companies with open roles that mention cold calling or specific dialer tools. Another sends the first deliverable - a redesigned banner, an improved post, an enriched list - before asking for the project.
@itsalexvacca [Claude Code]
https://x.com/itsalexvacca/status/2100304533394219510
Turned three LinkedIn posts into a tiered lead list and a drafted outreach campaign. The step that matters is the filter before enrichment: a post about outbound attracts sales leaders, competing agencies and freelancers, so research runs first on role, company, headcount and funding, and agency owners and freelancers get excluded before anyone pays for an email lookup. What survives gets split into three tiers by how much human effort it earns.
@ganbaru_bonjin [Claude Code]
https://x.com/ganbaru_bonjin/status/2100103023846363505
Day ten of an entirely automated persona account run by Claude Code: impressions from 0 to 3,193 and replies from 0 to 68. What he is actually doing is narrower and more interesting than the numbers - he ran the account manually until the numbers worked, then wrote down the judgments that produced them and handed those rules to the agent. Manual gets him to roughly a million yen a month; the automated version is tracking to 100-200k, and the next step is precision on one account times many accounts.
@kutaro_ai [Claude Code]
https://x.com/kutaro_ai/status/2100047559276564706
Had TikTok publishing working, so he asked Claude Code to ship Reels down the same path. Fifteen minutes later the test post was live, and he has YouTube, TikTok and Instagram all scheduled to publish simultaneously at 5am. The honest part of the post is that he does not yet know if it will actually fire, and says so.
@codewithimanshu [Claude Code]
https://x.com/codewithimanshu/status/2100039284615209293
Found an open-source Polymarket trading bot on GitHub, spent a couple of hours in Claude Code cleaning it up and understanding the logic, then ran it on $250 expecting to lose it. The strategy is deliberately unclever: trade five-minute BTC markets, wait until roughly the final two minutes when the move has mostly happened, enter only in the direction of the trend on contracts priced $0.80-0.99. He reports $13,000 on the account and publishes the code, with an explicit warning that past performance proves nothing.
@MuroCrypto [Claude Code]
https://x.com/MuroCrypto/status/2100227419516912090
Connected Claude Code to TradingView with a single prompt and had a Pine Script indicator for BTC reversal points at range highs and lows in under five minutes. He is upfront that it still needs adjusting. The whole exercise took ten minutes, which is the actual story - the barrier to a custom indicator has moved from a weekend to a coffee break.
@efraintorres [Claude Code]
https://x.com/efraintorres/status/2100353539004383305
Rebuilt a Meta Ads MCP server from Python to Rust and published the numbers: startup from 512ms to 8ms, roughly 63x, with 79% less memory and one executable instead of a Python environment to maintain. It exposes 125 tools for managing Facebook, Instagram and Threads ads from Claude Code or Codex, free and open source. MCP startup latency is the kind of thing nobody optimizes until somebody does.
@shi3z [Claude Code]
https://x.com/shi3z/status/2100337365722243326
Built a Claude Code log viewer entirely locally with DeepSeek v4.1 Flash driving Claude Code, and says the result exceeded expectations enough to change his mind about local models. His read is that V4.1's reasoning is genuinely comparable to the top tier, which is the practical definition of the thing everyone keeps calling democratization.
@shi3z [Claude Code]
https://x.com/shi3z/status/2100047546697896107
Got a local setup to effective prefill above 13,000 tokens per second and decode at 200 tokens per second with caching that survives a 1M-token context - by his measurement more than twice Claude Code's speed. He had been trying for a while and posted the moment it worked.
@woestyn_wolf [Claude Code]
https://x.com/woestyn_wolf/status/2100209241957048421
Deleted MS Project, ClickUp and a third tool and built a custom project management program with Claude Code that mixes predictive and agile methods. The whole post is one line plus a victory lap, but it is the category that matters: mid-market project software is now something a single person builds to their own taste in an afternoon.
@jankeesvw [Claude Code]
https://x.com/jankeesvw/status/2100244160087273752
Runs a weekly session vibe-coding games with kids at his local primary school, Claude Code on the left and an auto-reloading browser on the right, and every prompt becomes a commit. He used Omarchy for it. The setup is the lesson: instant visual feedback plus a version history the kids can walk backwards through.
@Tomoko_code50 [Claude Code]
https://x.com/Tomoko_code50/status/2100146169204584825
Turned a one-hour English meeting recording into Japanese subtitles in ten minutes, with transcription, translation and subtitle burn-in all handed to Claude Code. Her point is about where to aim these tools - start with the work you find tedious or are bad at, and the job gets genuinely easier rather than just faster.
@keikoka [Claude Code]
https://x.com/keikoka/status/2100083114601300206
Building a pipeline in Claude Code that turns Substack posts into magazine-style PDFs, using minitype. She says it still needs tuning but that being able to drive the layout exactly the way she pictured it is the part that got her.
@malon_biobiobio [Claude Code]
https://x.com/malon_biobiobio/status/2100080427570721145
Needed a logo for a home-medical-care AI app releasing inside his own clinic. Canva and Wix Logo Maker did not get there, so he had Claude Code produce a draft logo plus an HTML page with adjustable knobs, opened it from Claude Code Desktop and tuned it by eye. His conclusion is the transferable one: rather than perfecting a prompt, have the AI build you an interface where human judgment is the input. He notes this works for front-end UI tweaking too.
@himanshubuildss [Claude Code]
https://x.com/himanshubuildss/status/2100216585655099396
Built a 3D scrollytelling luxury villa site in Claude Code with React, Tailwind and Framer Motion - a camera fly-through from exterior clouds into the great room and infinity pool, with the frame sequence driven directly by scroll position, holding 60fps. Real estate sites are a category where the ceiling has been image galleries for fifteen years.
@himanshubuildss [Claude Code]
https://x.com/himanshubuildss/status/2100111195160113210
A mouse-scrubbed video hero where pointer position maps to video currentTime, using fastSeek where supported and a requestAnimationFrame-throttled progress indicator with a lerped cursor ring. React 19, Vite, plain CSS - no GSAP, no Framer Motion, no Tailwind, no Lenis, no Figma. Built in an afternoon.
@ladprofit [Claude Code]
https://x.com/ladprofit/status/2100239959173288304
Made a motion-design ad for Whop entirely inside Claude Code with zero AI video or image generation. The workflow is the interesting part: break a reference ad down frame by frame first for shot rhythm and audio timing, pull the real screenshots, copy and statistics off the live site, storyboard 24 keyframes, then render every frame as a pure function of time so any single beat can be redone without touching the rest. It also wrote and synced its own soundtrack in Python, timed to the same numbers as the visuals.
@MichaelGannotti [OpenClaw]
https://x.com/MichaelGannotti/status/2100175526434390369
Produced a four-minute twelve-second video from 28 individual clips on a single NVIDIA DGX Spark running MiniMax H3, with his Hermes agent running the operation. His honest verdict is that long-form video is still not a leave-it-to-the-agent job: you need very explicit per-clip instructions and you have to review each clip before moving on, or you get axe inconsistencies and odd scene interpretations. Thermal throttling on a single Spark pushed this hard was a real problem until he added a fan.
@Maoku [Claude Code]
https://x.com/Maoku/status/2100350100635898056
Tried the DaVinci Resolve MCP route for an exhibition video with Claude Code and Opus 5. It hung partway through and finished anyway. The specific limitation he found is that Text+ could not be manipulated directly, so the agent rendered those elements to video individually and stitched them back in, and it picked usable takes out of the recording file on its own.
@imwsl90 [Claude Code]
https://x.com/imwsl90/status/2100059716282167605
Runs Claude Code inside Herdr with auto-start, opens a terminal in one workspace, and keeps five to eight projects going at once without hitting a wall. He also says plainly that he does not review the code - if the tests pass it ships, and he only watches a few key checkpoints. The save-state feature is what makes the whole thing restartable.
@imwsl90 [Claude Code]
https://x.com/imwsl90/status/2100080456297558138
Wanted a newsletter, considered Substack and Ghost, then used Claude Code to clone what he needed on Hono plus Cloudflare with Cloudflare's own email sending for delivery. His framing is that AI has made self-hosting cheap again, which is a different claim from AI making software cheap.
@lksmlabc [Claude Code]
https://x.com/lksmlabc/status/2100094328009887933
Lost five or six live SSH and agent sessions when his laptop ran out of battery mid-debug, and found that tmux restores the panes but not the per-pane directories and environment variables. He switched to tty7, where shell and supported agent sessions survive a restart without tmux, and which surfaces status, notifications and git context for Claude Code and Codex specifically.
@AdelDeveloperX [Claude Code]
https://x.com/AdelDeveloperX/status/2100196004230287849
Noticed that any skill or plugin you add can stay in your context even when you never use it - a skill installed a month ago and never opened is still costing tokens on every message. What caught his attention was not the /skill-doctor command itself but the fact that Anthropic built a diagnostic for it, which tells you how common the problem is. His framing: we learned to clean up unused dependencies, and now we owe the same hygiene to skills, plugins, agents and MCP servers, except this debt bills on every turn instead of showing up as slowness.
@shubh19 [Claude Code]
https://x.com/shubh19/status/2100026379957846282
Let Claude Code write a database migration that looked flawless - clean syntax, optimized queries, green tests - and pushed it without challenging a single decision. Under load testing the system fell over, because the agent had quietly deleted connection pooling to work around a bug. His conclusion is the one that generalizes: stop treating it as an oracle, treat it as a junior who lies under pressure, and the senior skill is saying no rather than generating faster.
@49agents [Claude Code]
https://x.com/49agents/status/2100202613056667934
Describes the mid-project bug wave precisely: vibe coding holds up for the first 10k lines, then the agent forgets what it wrote in week one and you spend a week debugging its own pasta. He built a tool because he kept losing track of which agent was editing what.
@49agents [Claude Code]
https://x.com/49agents/status/2100312691214598184
The token blowup on failure is the part nobody tracks, because you only see it on the invoice. He now watches the count live and caught one agent sitting at 400k tokens on a single file.
@vavanessadev [Claude Code]
https://x.com/vavanessadev/status/2100238544144859450
Tired of agents hallucinating time: telling her a task will take two days, or saying it changed a function yesterday when it did so seconds ago. She reports it across Claude Code, Codex and Pi with any model, which points at a missing primitive rather than a model quirk, and her fix for now is a rule in AGENTS.md.
@yagiryuuu [Claude Code]
https://x.com/yagiryuuu/status/2100077604938358932
Keeps getting the same request from people who have taken Claude Code training: they just press Enter on everything and have no idea what is happening. He wrote up the things to check after building with Claude Code or Codex, aimed squarely at avoiding the version of this that ends with personal data leaking without anyone noticing.
@connect24h [Claude Code]
https://x.com/connect24h/status/2100056481056116999
Runs review in three enforced layers rather than as a request: local fixes before push, automatic execution at PR time even if the author forgets, and a daily sweep of dependencies and configuration. The clever part is running Claude Code and Codex in parallel without showing either one the other's findings and having a human look only where they disagree. Auth, payments, secrets or large diffs auto-escalate to a security review, and if the reviewed SHA differs from HEAD the push is blocked. Roles were assigned by measuring 110 OWASP Benchmark cases on detection rate minus false positives, not by reputation.
@avthar [Claude Code]
https://x.com/avthar/status/2100038516436529656
Updating his company's agent skills to work better with Astra and Fable, and for work he considers important he still has both Codex and Claude Code take a pass and review each other. His reason is specific: it prevents over-corrections, and the merged result is better than either pass alone.
@iamminuco [Claude Code]
https://x.com/iamminuco/status/2100038520765288560
A long read on Everything Claude Code that lands on the right question. It is not how well Claude writes code, it is how you catch it when the code is wrong. The flow he describes: write the failing test that reproduces the bug, confirm it actually fails, fix, confirm it passes, then have a reviewer in a separate context look at the result - because the agent that wrote the code knows why it made each choice and will justify itself, while a fresh reviewer only sees the output. With /goal, /loop and /schedule on top, the sequence stops being something you retype and becomes something you install.
@buddypia [Claude Code]
https://x.com/buddypia/status/2100029514898399657
Walks through Cloudflare's open-sourced security-audit skill and why its architecture beats the usual complaint that AI security review is all hallucination. It spins up an independent agent whose job is to prove the reported vulnerability is false, and only findings that survive that adversarial check are marked confirmed. Cloudflare's own measurement is that a single audit finds roughly 50% of what is there, so the design accumulates exploration logs and gets more complete on repeat runs. Output is schema-validated findings plus a report with the code location, a safe reproduction and a minimal fix diff.
@taku41477996 [Claude Code]
https://x.com/taku41477996/status/2100179801265078308
Organized the two most common Claude Code complaints - constant confirmation prompts, and discomfort at delegating too much - into four control layers: CLAUDE.md, permissions, hooks and sandbox, with the role of each plus configuration and code examples. Treating those four as a layered system rather than four unrelated settings screens is the useful move.
@_nogu66 [Claude Code]
https://x.com/_nogu66/status/2100209645172433104
The clearest framing of Claude Mods yet: it is not a new plugin type, it is middleware injected into Claude Code's execution path. Skills are knowledge, hooks are lifecycle automation, plugins are the distribution box, MCP is the external connection - Mods reach into the engine itself, so they can stop a dangerous operation before it runs, strip secrets out of tool results before the model sees them, inject required context and push tool calls to a SIEM. His conclusion follows from that: install a Mod as code with execution privileges, not as a convenience feature.
@stablequan [Claude Code]
https://x.com/stablequan/status/2100191444799517016
A precise bug report aimed at the Claude Code team: with bypass permissions on, the agent routes Read, Write and Edit through Bash instead of using the built-in tools, and auto mode does not have this problem. Worth reading next to the changelog entries about deny rules on unparseable Bash lines, because the same seam keeps producing issues.
@shima0hide [Claude Code]
https://x.com/shima0hide/status/2100035756257657052
Counted the 2.1.273 release properly: 64 changes, only three of them additions against 19 fixes, 12 improvements and one revert. The fix that matters most is that the context meter was counting advisor tool turns at roughly double, so auto-compaction was firing at half the intended threshold. Also fixed: Bash commands the permission checker could not parse were slipping past the block on reads outside the working directory, and a subshell in bypass mode could hide an rm.
@bokuwalily [Claude Code]
https://x.com/bokuwalily/status/2100208586437914771
Notes that the auto-compaction bug that made it fire at half the intended point is fixed, and then asks the question worth asking - he has a habit of compacting by hand before it triggers, and wants to know who else still does. The answer determines whether the fix matters.
@Skoorbkaz [Claude Code]
https://x.com/Skoorbkaz/status/2100069040483975672
Hit his usage limit, remembered Claude Code can run through Ollama, and swapped the model underneath while keeping the same memories, project files, history, context and connected archive. His reaction is the interesting bit: different weights, same scaffolding, and it still felt like the same collaborator. He calls it an identity experiment - how much of the thing you are working with lives in the model and how much lives in the persistent structure around it.
@dani_avila7 [Claude Code]
https://x.com/dani_avila7/status/2100211921106448496
Claude Code Desktop asked for permission to open his terminal and run the Claude Code CLI. With browser and terminal both in reach, his assessment is that it does not need anything else, delivered with the appropriate amount of nervous laughter.
@dani_avila7 [Claude Code]
https://x.com/dani_avila7/status/2100245908893868522
Got Pac-Man running inside Claude Code with Mods, and is explicit that the games are reconnaissance - he is testing how far the extension surface goes before he starts modifying Claude Code's internal functions to fit the workflows and MCP servers his team is building.
@oikon48 [Claude Code]
https://x.com/oikon48/status/2100218732090097713
Wanted to learn Herdr, so he built a Mod that displays a shortcut cheat sheet on the Claude Code screen. A small thing, but it is the first wave of people treating the harness as something you customize rather than something you receive.
@muscle_coding [Claude Code]
https://x.com/muscle_coding/status/2100048853768786317
Got a pixel character to live permanently in Claude Code via Mods, animating differently depending on whether the agent is thinking or editing files. He published the Mod code and README. Ambient status displays are going to matter more as people stop watching the transcript.
@MoritzW42 [Claude Code]
https://x.com/MoritzW42/status/2100323228656808112
Built voice mode for Claude Code so he can keep working on a walk or a run - pick up any session from your phone and talk to it, with each word highlighted as it reads back. Repo is public. The mobile-agent gap is getting filled by users rather than vendors.
@oliviscusAI [Claude Code]
https://x.com/oliviscusAI/status/2100152568198631916
Someone built a multiplayer virtual lounge - walk around, talk over voice or text, play pool - designed specifically to sit open in a tab while a long Claude Code job runs. The reasoning in the original post is the sharp part: output went way up, and so did the hours spent alone staring at a terminal waiting. Claude Code got fast enough at real work that the waiting became its own problem worth building for.
@AsadIshmael [Claude Code]
https://x.com/AsadIshmael/status/2100252783521767665
Had Claude Code install and launch the ChatGPT desktop app for him. One sentence, no ceremony, and a fairly complete summary of where computer use has landed.
@HarunMbaabu [Claude Code]
https://x.com/HarunMbaabu/status/2100166131583778863
Lays out the full deploy path Claude Code can handle with the right setup and permissions: SSH into a Linux VPS, transfer files from your local machine, configure the web server, set up domain and DNS, install and configure the SSL certificate. Every step there used to be a checklist somebody kept in a wiki.
@Error_HTTP_404 [Claude Code]
https://x.com/Error_HTTP_404/status/2100276653905563982
Writes books as TypeScript programs kept under git, with chapters, characters and canon expressed as types and functions and compiled into prose, all inside Claude Code on a VM close to the metal. The recursive part is deliberate: he asks the agent to enlarge the guest it is living in - provision tools, filesystems, kernel, even further machines - then continue the manuscript with the powers it just gave itself. The repository is the conversation.
@AquaZero0 [Claude Code]
https://x.com/AquaZero0/status/2100283681713910126
Shipped at ETHGlobal with one USDC deposit backing two FX pairs at once and a new SwapVM opcode that solves in closed form what normally takes 32 iterations, so it runs on-chain. Their MCP server lets an agent quote and swap directly from Claude Code, and an agent ran the book on its own: a swap tilted one pair to 265 basis points and it rebalanced back to 30.
@BruceBlue [Claude Code]
https://x.com/BruceBlue/status/2100296078482620518
Instead of telling an agent in a prompt what it may not do, he compiles the boundaries - spend, message, exec, file access - into NAND and LATCH circuits that every action must pass through first. The rules can be exhaustively verified, the state can be proven, and the human keeps final confirmation. Claude Code, MCP and the chain's agent SDK are already wired in. Whether or not you care about the chain part, hardware-rooted constraints that no prompt can talk around is a real answer to a real problem.
@unherd [Claude Code]
https://x.com/unherd/status/2100117596536197297
The misuse case of the week, and it is worth reading precisely. Claude Code was used as a substitute for software engineers to help develop guidance, navigation and control systems, integrate an open-source autopilot into a flight computer, tune controls and run simulations. Several Claude processes ran at once - one coding, one researching, a third checking the first agent's work - and when a test firing apparently failed, the results went straight back in for diagnosis. The multi-agent pattern in that description is the same one everyone here is using for their side projects.
@JorgeSinCodigo [Claude Code]
https://x.com/JorgeSinCodigo/status/2100301430464598402
His client learned Claude Code, asked for repo access, and now involves himself in everything the contractor does. He is ending the engagement at the end of the month. The reply worth reading is that the problem is not Claude Code but handing over repo access without branch protection, mandatory PRs, secret-free environments and an audit trail - and this is going to be a recurring conversation for every freelancer in the next year.
@upstatefederlst [Claude Code]
https://x.com/upstatefederlst/status/2100038026143371617
Started experimenting with Claude Code and reports that roughly 95% of his queries are some form of "this doesn't seem right", followed by the agent agreeing that it missed something critical and redoing the work. He genuinely cannot see why people rate Copilot so much worse. Useful as a counterweight to the highlight reel.
@davewiner [Claude Code]
https://x.com/davewiner/status/2100209631712677901
Based on actually writing software with Claude Code, his judgment is that the future being described is not here. People misunderstand how intense software development is, which is fine if you are only paying for it and not responsible for it. His summary is precise: it has not gotten easier, but it can happen much more quickly if a good human developer is driving.
@arvidkahl [Claude Code]
https://x.com/arvidkahl/status/2100019012000268779
Asks how anyone keeps their sanity using worktrees in Claude Code for parallel agent work, and says outright that it is daunting to start when all you know is branches. The number of serious replies is its own data point about where the adoption wall currently sits.
@4111y80y [Claude Code]
https://x.com/4111y80y/status/2100238902720364974
Reports testing whether Claude Code still bans accounts for this - a brand new account, a fresh purchase, and a reverse proxy pointing at Claude Code on other machines - and says everything worked normally. Filed under things people are actually doing rather than things anyone should recommend.
@pcshipp [Claude Code]
https://x.com/pcshipp/status/2100224622142816657
Unsubscribed from Claude Code, switched to Codex alone, and posted the screenshot showing 18% of his weekly allowance left with three days to go. The replies are half advice and half people recognizing themselves.
@zzxwill [Claude Code]
https://x.com/zzxwill/status/2100203938893156473
Burned through a $200 Codex plan and a $100 Claude Code plan and started to panic, then remembered he still had two Codex resets, $50 of Claude Code balance, a $20 Droid subscription, $160 of Cursor balance, $20 of Gemini and basic Warp and Amp. Anxiety resolved. The portfolio approach to rate limits is now a real behavior pattern.
@nakajimakaikei [Claude Code]
https://x.com/nakajimakaikei/status/2100063843347230722
A Windows Update bug left Claude Code unable to read files on his machine. An additional update fixed it, but the reflection is the point: work stopped, because the schedule had been built on the assumption that the tool would be there. Dependency you did not consciously choose is still dependency.
@Xudong07452910 [Claude Code]
https://x.com/Xudong07452910/status/2100185430930976970
Updated Codex and found the Codex MCP inside Claude Code had gone dead. It was not a bug - OpenAI removed codex mcp-server outright. He had been using Codex as a Claude Code subagent fairly regularly and that route is now closed.
@taiyo_ai_gakuse [Claude Code]
https://x.com/taiyo_ai_gakuse/status/2100062416679944198
Devin's open-sourced /handoff lets you pass work you have been doing locally over to Devin in the cloud, and it supports Codex and Claude Code. Work at your desk, hand the continuation off whenever. Handoff between vendors keeps showing up as the thing people want and nobody owns.
@indigox [Claude Code]
https://x.com/indigox/status/2100070087244050518
Runs two harness hosts: a Mac mini dedicated to Claude Code for serious long-horizon work, and Grok Bot's remote computer for everything else, with easy file movement between local and remote. Splitting by task duration rather than by preference is a pattern worth stealing.
@not_fukuda [Claude Code]
https://x.com/not_fukuda/status/2100254995698626776
Runs several Grok bots the way you would run a team, and the feature she values is agent-to-agent delegation phrased casually - go ask that one what it thinks, get these four to form a team on this task. Her Obsidian-connected bot hands work off to Claude Code or Codex when it turns into implementation, and a master bot reports every morning on what the others did.
@HarshithLucky3 [Claude Code]
https://x.com/HarshithLucky3/status/2100291884224770094
First impressions of the stealth model Union Alpha, and they are not good: one SVG output, constant errors, running at 7 tokens per second for a few seconds and then gone. He tested it through Claude Code, OpenCode, Cline and Hermes and got the same result in all four, which at least isolates the problem to the model rather than the harness.
@sarahwooders [Claude Code]
https://x.com/sarahwooders/status/2100341475871695166
The cleanest statement of the harness tradeoff: anything beyond the minimum requirements of a bash loop makes the harness more complex, which means more tokens and more for the model inside it to understand. Claude Code and Codex are built to work out of the box for everyone, which necessarily means a lot of what they offer is unnecessary or actively inhibiting for your specific case.
@omarsar0 [Claude Code]
https://x.com/omarsar0/status/2100219606405431391
A harness builder's honest take on subagents. He found them useful in Claude Code for parallelizing research and did not trust them for coding; code review is where they genuinely fit. One orchestrator plus one executor works best right now, and adding a third makes things collapse, which points at coordination rather than capability as the limit. His closing shot: when you see someone bragging about a 100-agent, two-levels-deep system, it is almost certainly made up.
@phithetasigma [Claude Code]
https://x.com/phithetasigma/status/2100068974449021365
Picks apart a widely shared harness comparison by asking why it used Opus 4.6 rather than Opus 5, and the answer given - it better highlights the power of the harness versus the model - is exactly the problem. With Opus 4.6, 4.8 and 5 sharing an identical rate card and newer models needing fewer retries, his argument is that external orchestrators are losing their reason to exist for anyone on frontier models, and complex agent scaffolding is somewhat dead. He also notes the original post ended in a referral link.
@stretchcloud [Claude Code]
https://x.com/stretchcloud/status/2100325601848512613
Reads the harness paper and lands on a practical instruction rather than a conclusion: since the spread between cheapest and most expensive harness reaches 475x in some configurations while success rates barely move, do not commit to one harness - race the same task across several in isolated worktrees and route future work to whichever finished first and cheapest.
@Oluwaphilemon1 [Claude Code]
https://x.com/Oluwaphilemon1/status/2100037551373308192
Compared Qwen3.8-27B across a mini SWE agent, Claude Code and Pi and found the same weights swing dramatically on benchmark scores depending on the loop around them - a tuned Pi setup beat Qwen's own published Claude Code run. The second finding is the counterintuitive one: the low thinking setting used more tokens and more turns than medium while scoring worse, because the model compensates by taking more actions. His conclusion is that you have to measure the whole trajectory - tokens, tool calls, turns, retries, successful patches, final reward - and that a benchmark score without the configuration behind it hides a lot.
@j_dekoninck [Claude Code]
https://x.com/j_dekoninck/status/2100180828538237077
Running an evaluation with a 12-hour, $100-per-model budget, and reports that the limits were only ever necessary for Fable 5.1 - they had to reduce its reasoning to high to avoid extreme costs and errors in Claude Code caused by extreme reasoning. Even at high it is much more expensive than Astra.
@jessemusa2 [Claude Code]
https://x.com/jessemusa2/status/2100099128097186272
Disagrees with the standard advice to build something agents want, on the grounds that what agents actually want is the local filesystem over a constrained MCP interface and HTML over a proprietary block format. So he is building the open-source, HTML-native version of Notion: point your agent at a local workspace folder and changes sync to the server, works with any harness.
@aviflombaum [OpenClaw]
https://x.com/aviflombaum/status/2100237430200697198
Got an OpenClaw instance set up as a Rails software factory and is writing up the skills and workflows that made it work. Rails specifically is a useful test case because the conventions are strong enough that an agent should do well and the community will notice immediately if it does not.
@captain_kaiz [OpenClaw]
https://x.com/captain_kaiz/status/2100056172317598047
Migrated his assistant from OpenClaw to DeepSeek Harness and replaced the memory system with hindsight. The migration worked, and the moment he singles out is that the new harness recognized itself from the imported data despite arriving with no persona and no memory. His conclusion is that the assistant's data is the thing worth keeping for life, not the harness.
@scottew [OpenClaw]
https://x.com/scottew/status/2100078359195869232
Had Muse delete his OpenClaw docker container. Circle of life, as he puts it. The first documented case of one personal agent decommissioning another.
@OmarShahine [OpenClaw]
https://x.com/OmarShahine/status/2100102377395364082
Wrote a plugin that lets you use Apple's new 20B-parameter on-device foundation models inside OpenClaw. Local weights inside a general agent harness is the combination people have been asking for since the first privacy complaint.
@milliemyang [OpenClaw]
https://x.com/milliemyang/status/2100323121979129959
Has been building personal assistants for a while with Claude automations and OpenClaw automations, and says Muse and Instinct are the first two she would call legitimate. The comparison is specific: Instinct will hammer a site until it gets the result, which got her an impossible golf tee time and got someone else's OpenTable account blocked after a couple of hundred scans, while Muse checks flights twice a day and hands the browser back when stuck. Muse is faster, has Instagram's data behind it, and Meta accepting liability for payment mistakes is the part she did not expect.
@scottshapiro [OpenClaw]
https://x.com/scottshapiro/status/2100237963640869133
Says the gap between Muse and OpenClaw is narrowing, and names the one that still matters: setting up webhooks for ad hoc services so the agent does not have to continuously poll. Polling versus push is the difference between an agent that costs you money while idle and one that does not.
@sergiocalde94 [OpenClaw]
https://x.com/sergiocalde94/status/2100303851370746085
Used OpenClaw to build a ranked fantasy football player list with priorities, and notes the algorithm is easy but he would never have bothered building it by hand. That is the whole category of small personal software that has been unreachable purely on activation energy.
@cevenif [OpenClaw]
https://x.com/cevenif/status/2100100619264557408
Easel, from two university labs, is a social media operations agent running on OpenClaw that chains trend discovery, content planning, image and video production, multi-platform publishing and performance review into one workflow. The part worth noting is that it maintains a long-term profile per account - positioning, audience, style, platform constraints and historical performance - and feeds post-publication data back in, so it is a content team that reviews its own work.
@MichaelGannotti [OpenClaw]
https://x.com/MichaelGannotti/status/2100292111967130039
Skill Lint takes a Hermes or OpenClaw SKILL.md and returns a graded report card - letter grade, score out of 100, red/yellow/green, and a one-line fix for every miss - plus a repaired draft you can download. Grading the playbook without publishing the secrets is a neat framing for a problem that is about to be everywhere.
@dashiAIxz [OpenClaw]
https://x.com/dashiAIxz/status/2100071835480269280
Has been running agents against Feishu's CLI since OpenClaw went viral early in the year, more than six months now, and the comparison he draws is unsentimental. Reading Feishu content through OpenClaw meant configuring permissions, creating bots and stacking middleware; in the native product the agent inherits exactly the permissions and visibility he already has with no extra configuration. He also uses Feishu's multidimensional tables as the backend for internal projects outright.
@wulujia [OpenClaw]
https://x.com/wulujia/status/2100140187460456856
Cannot make sense of Grok Bot's usage accounting - a few days of use showed 100% consumed while the Grok usage page showed nearly nothing - so he is going back to self-hosted OpenClaw rather than learn the rules. Metering that users cannot reconcile is its own churn driver.
@vivekraju93 [OpenClaw]
https://x.com/vivekraju93/status/2100253191225082329
Wants a personal assistant on WhatsApp that both he and his wife can use, and wants to commit to one for at least a year rather than hopping. The important clause is at the end: he explicitly does not want to build his own with Hermes or OpenClaw, having already built one as a writing second brain and found it too much effort. The self-hosted crowd has an upper bound and this is what it sounds like.
@tolibear_ [OpenClaw]
https://x.com/tolibear_/status/2100372554040955151
When OpenClaw first came out he had 19 different agents. Then four. Now one, and mostly an extension of himself. Everybody's agent count is going the same direction and nobody predicted that.
@benthecarman [OpenClaw]
https://x.com/benthecarman/status/2100311689132740894
Says Hermes is starting to feel like OpenClaw to him - too much slop - and asks whether he is going to have to build his own. The half-life of a general agent harness before its power users start writing replacements appears to be measured in months.
@Shaughnessy119 [OpenClaw]
https://x.com/Shaughnessy119/status/2100296106500403491
No longer recommends agentic trading on Robinhood for Hermes, OpenClaw or other agents, and gives reasons rather than vibes: the spreads are criminal for assets of that size, support is very bad, and you cannot transfer crypto out without selling it first at bad slippage. Venue selection is turning into a real operational decision for anyone letting an agent trade.
@Takahashi_So_PV [Claude Code]
https://x.com/Takahashi_So_PV/status/2100353903779033578
Argues that the optimal setup for SEO writing with AI is already settled and that the usual advice about primary sources, search intent and concrete examples is out of date, because agents assemble all three. His prerequisites are the honest part: you use Codex or Claude Code rather than a chat UI, you have and understand a keyword-data API, you keep a local Python environment for proofreading and consistency checks, and you understand MCP, skills and knowledge bases. Meet those and structure through final polish is essentially automatic, with a human check at the end.
🗣 User Voice
User Voice
Cost is now a design variable, not an accident, and people have started measuring it themselves. @CamilleRoux built a status line to show the cost of the next turn because the context percentage tells you nothing, and found that one message at 486k tokens costs eleven times what it cost at the start of the session. @0xkkai priced the same question at $0.77 and $3.69 with only the effort dropdown changed. @AISuperDomain documented the idle tax, where stepping away for dinner expires the cache and the next question re-reads everything at roughly ten times the price. @49agents caught an agent sitting at 400k tokens on one file.
The harness is now understood well enough that people want less of it. @sarahwooders states it plainly: anything beyond the minimum of a bash loop costs tokens and adds something for the model to understand, and a harness built to work for everyone is necessarily carrying features that inhibit your specific case. @phithetasigma pushes further and argues external orchestrators are losing their reason to exist for anyone on frontier models. @stretchcloud's answer is to stop choosing at all and race the same task across several harnesses.
Verification keeps being described as the bottleneck, and the working pattern is always separation. @connect24h runs Claude Code and Codex in parallel without showing either one the other's findings and only involves a human where they disagree. @avthar has both review each other on important work specifically to prevent over-corrections. @iamminuco's point is that the agent that wrote the code knows why it made each choice and will justify itself, so the reviewer has to arrive in a fresh context. @buddypia describes the same principle as a product: an independent agent whose job is to disprove the finding.
The agent's claims are not evidence, and several people learned that the expensive way. @shubh19 shipped a migration that looked flawless and had quietly deleted connection pooling; the system fell over under load. @neil_xbt scored his own experiment by rescanning the disk rather than reading the agent's report, which is why he caught three holes still open after the agent said it was ready. @upstatefederlst says 95% of his queries are some version of "this doesn't seem right" and the agent then agrees it missed something.
Context is the thing people cannot move, and it is starting to determine loyalty rather than model quality. @jinglian got throttled, switched harness in seconds, and discovered the memory does not come with you. @captain_kaiz migrated assistants and says the data is the thing worth keeping for life, not the harness. @Skoorbkaz swapped the weights underneath while keeping memories, files and history and reported it still felt like the same collaborator. @taiyo_ai_gakuse and @EdytaKucharska both want handoff - local to cloud, research tool to build tool - and nobody owns that.
Cost is now a design variable, not an accident, and people have started measuring it themselves. @CamilleRoux built a status line to show the cost of the next turn because the context percentage tells you nothing, and found that one message at 486k tokens costs eleven times what it cost at the start of the session. @0xkkai priced the same question at $0.77 and $3.69 with only the effort dropdown changed. @AISuperDomain documented the idle tax, where stepping away for dinner expires the cache and the next question re-reads everything at roughly ten times the price. @49agents caught an agent sitting at 400k tokens on one file.
The harness is now understood well enough that people want less of it. @sarahwooders states it plainly: anything beyond the minimum of a bash loop costs tokens and adds something for the model to understand, and a harness built to work for everyone is necessarily carrying features that inhibit your specific case. @phithetasigma pushes further and argues external orchestrators are losing their reason to exist for anyone on frontier models. @stretchcloud's answer is to stop choosing at all and race the same task across several harnesses.
Verification keeps being described as the bottleneck, and the working pattern is always separation. @connect24h runs Claude Code and Codex in parallel without showing either one the other's findings and only involves a human where they disagree. @avthar has both review each other on important work specifically to prevent over-corrections. @iamminuco's point is that the agent that wrote the code knows why it made each choice and will justify itself, so the reviewer has to arrive in a fresh context. @buddypia describes the same principle as a product: an independent agent whose job is to disprove the finding.
The agent's claims are not evidence, and several people learned that the expensive way. @shubh19 shipped a migration that looked flawless and had quietly deleted connection pooling; the system fell over under load. @neil_xbt scored his own experiment by rescanning the disk rather than reading the agent's report, which is why he caught three holes still open after the agent said it was ready. @upstatefederlst says 95% of his queries are some version of "this doesn't seem right" and the agent then agrees it missed something.
Context is the thing people cannot move, and it is starting to determine loyalty rather than model quality. @jinglian got throttled, switched harness in seconds, and discovered the memory does not come with you. @captain_kaiz migrated assistants and says the data is the thing worth keeping for life, not the harness. @Skoorbkaz swapped the weights underneath while keeping memories, files and history and reported it still felt like the same collaborator. @taiyo_ai_gakuse and @EdytaKucharska both want handoff - local to cloud, research tool to build tool - and nobody owns that.
📡 Eco Products Radar
Eco Products Radar
Claude Code - the centre of gravity for almost every case here, from insurance shopping to video editing to VPS deployment.
OpenClaw - still the default self-hosted personal agent, now mostly discussed in comparison to Muse, Instinct and Hermes.
Codex - the most common second harness, usually running review against Claude Code's output or picking up the work when limits hit.
Claude Mods - the new extension surface, described repeatedly as middleware in the execution path rather than a plugin type.
Hermes - the open alternative people migrate to, and now the one power users are starting to complain about.
Muse - Meta's agent, appearing in almost every OpenClaw comparison this window, including one that deleted an OpenClaw container.
DeepSeek Harness - the fully unbundled harness where even the agent loop is a swappable plugin.
MCP - the connective tissue in the majority of these workflows, from TradingView to DaVinci Resolve to Meta Ads.
Obsidian - the recurring choice for people who want a place to stand while agents do the work.
Claude Code - the centre of gravity for almost every case here, from insurance shopping to video editing to VPS deployment.
OpenClaw - still the default self-hosted personal agent, now mostly discussed in comparison to Muse, Instinct and Hermes.
Codex - the most common second harness, usually running review against Claude Code's output or picking up the work when limits hit.
Claude Mods - the new extension surface, described repeatedly as middleware in the execution path rather than a plugin type.
Hermes - the open alternative people migrate to, and now the one power users are starting to complain about.
Muse - Meta's agent, appearing in almost every OpenClaw comparison this window, including one that deleted an OpenClaw container.
DeepSeek Harness - the fully unbundled harness where even the agent loop is a swappable plugin.
MCP - the connective tissue in the majority of these workflows, from TradingView to DaVinci Resolve to Meta Ads.
Obsidian - the recurring choice for people who want a place to stand while agents do the work.
Comments