Super User Daily: 2026-09-21
The clearest thing on the timeline was that people stopped arguing about which model wins and started measuring what the wrapper around it costs. Two independent measurements of the same phenomenon landed within hours of each other, one of them putting the same model at roughly double the price inside one harness versus another, and a third person just ran the context command and posted the receipt. Alongside that, the verification gap got its cleanest statement yet from somebody who shipped on 126 green checks and then counted seven bugs on screen. The non-coding side keeps widening: contract review with a statute ledger, patent disclosure drafts, accounting where the model only handles the exceptions, a print-ready leaflet, a travel map built from a family photo library, and a book-reselling tool written by somebody who says he does not know what code is.
@alexgetmancom [Claude Code]
https://x.com/alexgetmancom/status/2101411232771113143
Stripped Claude Code down to three tools - read, inspect, write - and threw out almost everything else, getting startup context under 2k tokens. Also capped the context window at 200k so it compacts earlier instead of chewing through the quota with bloated context. The whole thing runs on the $20 Pro plan with Opus 5 on low effort, which he says is the only setup that makes sense for real work. Says it pushes Claude Code close to Pi's minimal approach and he wants to see how far a $20 subscription stretches like this.
@Yuchenj_UW [Claude Code]
https://x.com/Yuchenj_UW/status/2101362635128401978
Posted his current model-plus-harness stack: Kimi K3 as the best open-source coding model, GLM-5.3 next, DeepSeek V4.1 Flash for easy and moderate tasks because it is fast and cheap, and Astra reserved for complex work. The line that matters is the last one - Codex works better with open-source models, and Claude Code can make the same model cost twice as much. That is a harness-level cost claim, not a model claim, and it lines up with several other measurements circulating the same day.
@NFT_Chen [Claude Code]
https://x.com/NFT_Chen/status/2101167045740294325
Walked through a Berkeley comparison that put the same models into three harnesses - Claude Code, Codex and Pi. On the same task with the same model, Claude Code scored 97.8% at $1.33 while Pi scored 96.7% at $0.67: one extra correct answer for double the money. Overall Claude Code came in at roughly 2x Pi and 1.6x Codex, and on the terminal set about 1.5x Pi. The cause he points at is that Claude Code stuffs ten times more instruction text into the model per turn, which he calls a harness tax paid on every round.
@zainhas [Claude Code]
https://x.com/zainhas/status/2101179902708101503
Measured input and output tokens per task across six different harnesses running the same model, Kimi K3, on twelve tasks that all got solved. The comparison isolates the harness because the model and the task set are held constant, which is the only way this number means anything. His read: Claude Code is pretty token hungry, Pi outputs a lot of tokens, and Codex sits in the middle of the pack. Two independent measurements of the same phenomenon landed the same day.
@lucas_builds [Claude Code]
https://x.com/lucas_builds/status/2101340544786170068
Shipped on 126 green checks, then opened the app and counted seven bugs. His explanation is the sharpest version of the verification problem anyone posted this window: Claude Code wrote both the code and the checks, so green only ever meant the code did what the agent expected it to do. The bugs were sitting on the screen, where no check was looking. He ended by asking other Claude Code users what they still verify by hand before shipping.
@muse_jp_sol [Claude Code]
https://x.com/muse_jp_sol/status/2101332990978600992
Claude Code changed an auth check to return true, the tests passed, and it was ready to call the job done. Instead of writing a longer prompt, he built jev-preflight: a separate fast decision model flags the risk across eight axes in one request and sends Claude back for at most one re-check. The design constraint is the interesting part - one request, one maximum re-check - because a review layer that can loop forever is just another cost sink. Released as an open-source beta.
@notEgoyard [Claude Code]
https://x.com/notEgoyard/status/2101244115832705527
Responsive layout bugs almost never show up in the editor; they show up at exactly 743px, invisible until someone happens to drag a window to that width. His fix is not smarter CSS, it is closing the loop: one Playwright MCP prompt resizes to a target width, reloads, runs a script flagging every element wider than its container, screenshots the failures, reads the source, fixes the rule, reloads and rechecks - and only moves to the next breakpoint once the current one comes back clean. A separate mobile skill extends the same loop to touch targets with a 44px minimum height and 8px spacing, verified by screenshot after every simulated tap rather than assumed.
@richardchang [Claude Code]
https://x.com/richardchang/status/2101133409364144327
Passed on a habit from an Anthropic engineer: keep a global papercuts.md shared across all sessions, and every time something slows development down mid-task, append one line - date, symptom, fix, project. When a tool misbehaves later, check that file first. The quote he pulls out is the real finding: 'I always suspected Claude Code was spending a lot of time working around problems I never noticed, because I no longer watch sessions the way I used to. The answer is yes.' His own worry is the same - with auto mode plus lots of subagents, memory only ever records the friction he happened to witness, while silent retries and reroutes never enter any file.
@suna_gaku [Claude Code]
https://x.com/suna_gaku/status/2101130304073433287
Broke down eight skills that survived half a year of daily Claude Code use, and the rules are more useful than the skills. Build a skill from a recurring pain, not from something that looks handy. Keep deleting instructions as models improve - the 'always' and 'never' and 'verify this' lines that were once necessary become noise. Make a skill-making skill first, push deterministic work into Python or Bash and unit-test those scripts. Treat the expensive model as the one that decides rather than the one that does everything. And for unattended runs, write a verifiable completion condition before writing the task, because self-reported 'done' does not count.
@cyrilXBT [Claude Code]
https://x.com/cyrilXBT/status/2101137234820993441
Stop using AI purely to write code and point Claude Code at a folder instead. His setup is seven steps: install Obsidian, make a vault, open it in Claude Code, describe the system and let Claude build it, end up with three folders - raw for sources, wiki for its own pages, and a CLAUDE.md that runs the whole thing. Then drop any article, transcript or PDF into raw and say 'ingest this'. The claim is that it compounds: the more you feed it, the less often you start from a blank chat.
@masaru_growth [Claude Code]
https://x.com/masaru_growth/status/2101131472094863720
Turned contract review into an in-house skill for a company with no legal staff, and the three design rules are what make it usable. First, give the model your side before it reads anything - are you the contractor or the client, what do you defend and what do you concede - so generic legal knowledge lands on top of an actual stance. Second, never let it write article numbers from memory: he built a ledger of 54 provisions machine-matched against the e-Gov statute API, and anything not in the ledger has to be labelled general commentary requiring confirmation. Third, revisions come out as Word-style strikethrough and bold, diffed by script against the clean version, so it does not delete everything and rewrite. A ten-condition test decides each time whether a lawyer needs to see it - his framing is that AI is not a substitute for the lawyer, it is the filter that narrows what goes to one.
@XAMTO_AI [Claude Code]
https://x.com/XAMTO_AI/status/2101129441204453791
Patent disclosure drafts mean block diagrams, flowcharts and endless Word revisions. The skill he found reads the project docs and the code, lists the candidate patentable points, runs a light search against the national IP administration's published announcements, produces a template-conforming disclosure with diagrams, and exports to Word after redaction. Supplementary material is saved as a new version rather than overwriting the old draft. He is careful about what it is not - this is a draft for the patent agent to edit, not a novelty finding and certainly not a grant.
@creditship_dx [Claude Code]
https://x.com/creditship_dx/status/2101454540444737906
Ran an automation test for accounting work with Claude Code against the MF API, and the design decision is the point. The AI only makes a judgement call when the case does not match past data, office rules or client rules - everything covered by an existing rule never reaches the model at all. Then whatever was processed this month becomes a rule update feeding next month's run. That is a rules-first architecture with the model as the exception handler, which is the opposite of how most people wire this up.
@mizkun [Claude Code]
https://x.com/mizkun/status/2101164357795328184
Started a holiday-week writing series on what his company actually learned from AI transformation, and the first piece is about handing Claude Code to every single business-side employee, not just engineers. The follow-ups he promises are interviews with the people on the floor and with the security lead, which is the half of this story that almost never gets published. Company-wide rollout posts usually stop at the announcement; this one is going to include what the security person thinks about it.
@blaslo01241 [Claude Code]
https://x.com/blaslo01241/status/2101143491048804583
Runs two YouTube channels plus X and Threads alone, and says it works because of division of labour rather than grinding. Claude Code does the instruction and supervision, Codex does images, fal does video, audio and sound effects. Competitor numbers collect themselves automatically at midnight every night. What she does is decide, and look at the finished thing at the end. The honest part: at first she touched everything herself, opening images one at a time and fixing them one at a time until the day was gone. Now she gets a pass/fail table from another handler - she went from the person who moves their hands to the person who judges.
@ganbaru_bonjin [Claude Code]
https://x.com/ganbaru_bonjin/status/2101139625255547316
On his fourth automated persona account and shared the three things that actually matter. First, make the AI see the account as a line rather than a point - feed it the account design, the past posts and the current phase so each new post is written inside the account's whole story, not standalone. Second, put the goal in the instruction, not just the task: stop the scroll in the first line, match the concept, include emotional range, leave room for a reaction. Third, move the human judgement into the model too - generate, evaluate against five checks, revise, re-evaluate, then post. His summary is that automation is not handing over the work, it is handing over the judgement.
@kutaro_ai [Claude Code]
https://x.com/kutaro_ai/status/2101441411879157812
Views were climbing while affiliate clicks fell day after day until they hit zero. Asked Claude Code why and got the blunt correct answer back: the videos never mention the link. Then he took a technique from another creator's post and had a self-pressing button animation built in seven minutes, and is rolling it into every video from the next day. A small case, but it is the clean shape of the thing - a metric going wrong, a diagnosis, and a fix that took minutes instead of a redesign.
@akirahonsedori [Claude Code]
https://x.com/akirahonsedori/status/2101298453213258158
Explains why his posting has dropped off lately - he is building a tool for his book-reselling business with Claude Code. Worth including precisely because of what he says about himself: he does not know what code is or what a program is, he is just the one giving instructions. The combination he names is ChatGPT plus Claude Code, and the reselling side has slowed down while he builds. This is what the non-engineer end of the adoption curve actually sounds like.
@esadsaglam0 [Claude Code]
https://x.com/esadsaglam0/status/2101165674043228434
Replied to a channel quoting vendor prices to say he owns that channel and produces the videos on his own PC with Claude Code, fully automatically, for less than what those vendors quote. He also generates the voice that best fits his avatar through ElevenLabs by prompt instead of picking from stock audio, and he is not locked into any single editing template. His advice was to just go discuss it with your own Claude rather than staying tied to monthly software subscriptions.
@AaronxShepherd [Claude Code]
https://x.com/AaronxShepherd/status/2101099221881671942
Account scoring used to be a 40-step build; he did it with Clay's API plus Claude Code and got numbers back. He handed Claude an ICP and a set of buying signals - hiring SDRs, hiring demand-gen, headcount climbing, competitor tooling, recent funding - and let it pull and rank accounts itself. Out of 284 accounts pulled: 11 scored hot, 43 warm, 54 worth working when the calendar clears. Then he set it to re-score weekly and ping Slack when an account heats up or cools off. The reason he bothers is that most teams score leads by guessing or not at all, so the best sending days get burned on people who were never going to buy.
@FavourYusuf1 [Claude Code]
https://x.com/FavourYusuf1/status/2101380484131422476
Wrote up how he uses Claude Code and Hermes Agent to find actual leads. You paste the prompt, it spawns an agent, it asks a few questions to pin down your niche, then works out who the target is, where they gather, and which signals separate a good prospect from an okay one. His worked example for a content writer: companies that raised in the last six months so there is money, a dead blog with nothing posted in three months so they started and had nobody to run it, or a founder posting erratically so they need the heavy lifting done. It writes leads to Notion and then turns the whole routine into a scheduled task that runs every Monday so there is always a fresh batch waiting.
@ruthybuilds [Claude Code]
https://x.com/ruthybuilds/status/2101253991644688812
Asked Claude Code to go through the past week of Fireflies recordings and collect client feedback. Small in scope, unusual in kind - this is meeting transcripts as an input source rather than a codebase, and the output is a feedback digest for a marketing agency rather than a diff. Worth noting because the non-coding uses that show up in this feed are almost always writing or research; this one is operational review.
@alexgoughcooper [Claude Code]
https://x.com/alexgoughcooper/status/2101126881437171755
Built a Q4 static-ad skill on top of a set of winning templates that an MCP surfaced for him, and the loop is the interesting bit: the artifact lets him give feedback on either the template or the skill itself, so the more he uses it the better it gets. Claude Code's interactive artifacts as an editing surface for the skill, not just an output viewer.
@Daisaku_sw [Claude Code]
https://x.com/Daisaku_sw/status/2101148178313781597
Says automating SEO article production with Claude Code is harder than it looks: no matter how strict the rules, it still routinely outputs things that are factually wrong, Japanese that reads unnatural, and passages that give the reader nothing - none of which can be delivered as is. So he splits the work into at least six stages, outline, skeleton, and first through fourth drafts, and checks each one with his own eyes before delivery. A useful counterweight to the same-day posts claiming fully automated content pipelines.
@rodrigorojop [Claude Code]
https://x.com/rodrigorojop/status/2101390797362835961
Bought an Asus Zenbook with one of those trackpads that turns into a numeric keypad at the press of a button, put Omarchy on it, and found the feature did not work. So he did what any sane person does and asked Claude Code for help, and it got fixed. The end of the story is the good part: he sent the PR upstream, and it was the first pull request he has ever submitted.
@vladkrutenyuk [Claude Code]
https://x.com/vladkrutenyuk/status/2101339200536641994
His complaint about AI slop on three.js is that you get output you have no idea how to modify - pure prompting is a black box generating a black box. So he built the tool first and then gave it an MCP server: a real 3D engine living in a browser tab, with an editor, fully exposed to agents. Connect Claude Code or Cursor to the open tab and it builds inside your scene while you watch; his demo was asking it to rewrite a magic tree shader into animated lava. The result is not a wall of code, it is a scene you can open, click and change.
@Granite0x [Claude Code]
https://x.com/Granite0x/status/2101249433706938647
An ex-Apple Human Interface and ex-Google Glass designer rebuilt a Photoshop-class editor with Opus 5, and all fifteen feature commits carry the same Co-Authored-By trailer. The spec is not a demo: 7.1MB download, layers, groups, blend modes and layer masks, Content-Aware Fill and healing written from scratch in C, a brush running on a Metal kernel rather than the CPU, non-destructive transforms at full resolution, and 7,263 lines of tests next to 16,755 lines of app. The first commit lands 179 files and 24,764 lines at once. 1,360 stars in three days, MIT licensed.
@BrierRat [Claude Code]
https://x.com/BrierRat/status/2101435792896008301
Describes FaenoCAD as not a CAD program with an AI window bolted on, but a system an engineer uses to build designs. Two models split the job inside the harness: Fable infers design intent, Astra does the CAD. The core is a memory system that keeps a running record of every build it has done and creates reusable skills as it goes, so it learns the way an engineer learns - from experience, and not just about how to design but about how the user and agent interact to make a new design. The viewer is deliberately stripped down and agent-first, talking to the harness through MCP tools, and the whole thing is bring-your-own agent: Claude Code, Codex, OpenClaw, whatever you have.
@sankivraja [Claude Code]
https://x.com/sankivraja/status/2101414839415697594
453 new GitHub contributions in a week, and 1,129 commits across eight repositories so far in September, most of it concentrated on one project and its supporting infrastructure. The line worth pulling out is about maturity rather than volume: the Claude Code plus Codex workflow has moved past proving the combination works and into improving how the two systems plan, review, challenge and validate each other through development. His framing is that the focus is no longer producing more code but building a development system that can reason about, verify and improve the software it produces.
@BradGroux [OpenClaw]
https://x.com/BradGroux/status/2101137804252094501
Kept hitting the same dumb problem - feeding YouTube videos to his AI through Codex, Muse, OpenClaw and Buzz, and every route was annoying. Paste a link and pray the agent can fetch it, watch it burn thousands of tokens pulling the page and choking on markup, or install a bloated extension full of popups and analytics. So he built Minimal Transcript: open a video, click the icon, get TXT, Markdown, SRT or VTT with timestamps optional. The token argument is the real one - on a three-hour video, that is a few thousand tokens of clean captions instead of tens of thousands wasted. Details he sweated: prefers real captions over auto-generated, strips YouTube's hidden screen-reader junk, and falls back to driving YouTube's own transcript panel when the download endpoints are gated.
@EXM7777 [Claude Code]
https://x.com/EXM7777/status/2101371746003845539
Argues for putting your agents on a VPS and walks the whole setup. One big rented machine in a data centre runs everything - his Hermes agent, Claude Code, Codex. The server is invisible to the public internet and only accepts connections from devices inside his private Tailscale network, so any machine that joins reaches it by name as if they were in the same room. Chats and jobs live on the server rather than the laptop, so the same sessions show up from any device. Logging in needs his key file and passwords do not work at all. Every program runs under its own limited account so a bug in one cannot touch the others, API keys sit in admin-only files, security updates install themselves, an intrusion guard bans attackers, and a backup runs hourly. His closing note: a very cheap model can set all of this up for you.
@andpoul [Claude Code]
https://x.com/andpoul/status/2101119543280271455
Remote dev on a Mac mini over Tailscale is still going great months in. iOS app with notifications, plugins, and Codex plus Claude Code plus Pi all running on subscriptions rather than API billing. The detail he throws in at the end is the one that keeps showing up across this feed this week: the various agent flavours can talk to each other.
@sp3cul8r [OpenClaw]
https://x.com/sp3cul8r/status/2101309139079102677
Has been running a lot of financial intelligence work on his OpenClaw instance, which lives on a Mac mini, and is now hearing good things about Muse and Grok Bot. His question to the timeline is the honest version of what a lot of people are quietly asking this week: is there a reason to switch away, what am I missing, and what would it actually buy me. Nobody in the replies had a crisp answer.
@xenpub [OpenClaw]
https://x.com/xenpub/status/2101271051497828724
Runs his own agents - Hermes for server maintenance and OpenClaw alongside it, plus a personal assistant that tracks his schedule and reminds him about birthdays. The cost he names is the one people skip: tokens, plus having to build a secure sandbox for each agent to isolate its work. He has now started testing Muse, and the technical detail he approves of is specific: the agent lives inside an air-gapped Debian container with 2 vCPUs, 8GB RAM and 8GB storage, a firewall and a zero-trust credential engine, with long-term memory in Postgres, all on a dedicated end-to-end encrypted VM. His caveat is equally specific - he would not let it touch his servers or store anything sensitive until someone works out BYOK.
@TheOneGroupAI [OpenClaw]
https://x.com/TheOneGroupAI/status/2101332248859386352
Built a side project during a family trip around Europe: drop photos into a shared library and OpenClaw turns them into an interactive travel map with photos and memories pinned to each place. Started as a family keepsake, and he is now asking the timeline whether it could be a product. The bit that makes it a real case rather than a demo is the trigger - the input was the photo library that already existed, not a dataset assembled for the purpose.
@cleary79 [OpenClaw]
https://x.com/cleary79/status/2101456501709635822
Gave a twelve-year-old Surface Pro 3 a second life with Omarchy: seven workspaces, an Octopus Energy dashboard, and OpenClaw at his fingertips, with coding, research and home controls all in one place. The thing worth noticing is which hardware tier this runs on - the agent-on-a-personal-machine story usually arrives attached to a new Mac mini, and this one arrived on a laptop from 2014.
@tusharck9 [OpenClaw]
https://x.com/tusharck9/status/2101207526637461866
Shipped an OpenClaw channel plugin for WhatsApp built on WhatsApp's official Agent Platform API, and the framing is about what he did not do: no QR hacks, no unofficial libraries, no ban risk. Live on ClawHub and open source. Worth flagging because a large share of the WhatsApp agent bridges circulating in this ecosystem are built the other way, and their users find out about the ban risk the hard way.
@fjpedrosa86 [OpenClaw]
https://x.com/fjpedrosa86/status/2101279128171274253
First run of an agentic experiment: get OpenClaw to order him food. He had to fight the browser and residential proxy configuration for a while, but OpenClaw can now connect to Just Eat and run searches. He placed the actual order himself this time, because two things are still pending - adding a prepaid card so the agent can pay, and opening it an account with a username and password so it can sign in. That gap between 'can browse and search' and 'can complete a transaction' is exactly where most consumer agent demos quietly stop.
@shields_pikes [OpenClaw]
https://x.com/shields_pikes/status/2101320048304607341
Had his OpenClaw assistant drive a fast decision model through a pile of clerical work, and the one that came out clearly useful was classifying unwanted newsletters and sales email - accuracy was good. He points out why: judging whether something reads like a newsletter needs no background context, which is exactly the shape of task that suits a cheap classifier. His proposed split is to let the classifier do the sorting and hand only the detailed check and the actual unsubscribe flow to the LLM agent. Also notable: everything except fetching the API key and setting the environment variable was built by the agent itself, driven from a Discord channel.
@robmrtnz [OpenClaw]
https://x.com/robmrtnz/status/2101330163346870509
Let capture stay messy and put the structure downstream. His four-layer playbook: one inbox for text, voice and screenshots with no required titles or tags and offline saving, because transcription can happen later. Keep the originals in Obsidian or something equally durable and exportable, with AI summaries sitting beside the source rather than overwriting it - the weird little phrase is often worth more than the polished summary. Make the agent the interface for capturing, finding and developing ideas, with explicit filing and linking workflows so you are not doing admin. And keep synthesis separate from search, so neither becomes a competing source of truth. He is explicit that this is architecture, not product: installing an agent does not create reliable memory, the workflows have to be configured.
@LopezSemper1 [Claude Code]
https://x.com/LopezSemper1/status/2101281780884033594
Tested intent-based security on Claude Code for the first time and reported what actually happened rather than the pitch. Setup was one curl command plus device authorization. Claude had to register what it planned to build before running any tool calls. He switched the policy profile to strict-read-only from inside the chat prompt itself, then asked Claude to modify the site design - and the file edit was blocked at the hook under default-deny. Every request and every blocked action showed up live on a dashboard. His conclusion: letting agents develop is good, but having something that stops bad commands from reaching your disk is everything.
@ClaudeCode_aca [Claude Code]
https://x.com/ClaudeCode_aca/status/2101144258451587556
A personal tool called Passtrami connects the macOS Passwords app to agents over MCP, and the design rule is that the agent never sees the secret: every time it asks, the human approves one entry with Touch ID, and the plaintext password never lands in the agent's conversation log. It works across Codex, Claude Code and Cursor. What makes it notable is the lineage - it takes the never-return-the-value idea from 1Password's official MCP server and brings it to Apple's built-in password app, as an individual project. Routine logins are only going to get delegated more, and this is what delegating without handing over the secret looks like.
@onusoz [OpenClaw]
https://x.com/onusoz/status/2101335826580066635
One operational tip with a real threat model behind it: create a separate Linux user account for the agent that crawls the net, such as your OpenClaw, then point the Hugging Face cache at a user-agnostic path like /srv/huggingface and give the agent accounts read access to that folder. You reuse local models across multiple users while isolating your main account from prompt injection risk - and his note that local models are generally smaller and can be more susceptible is the part most people skip. The side benefit he mentions is not filling a 1TB DGX Spark with duplicate weights.
@Qvist_dev [OpenClaw]
https://x.com/Qvist_dev/status/2101222287449944269
Three scanners, 62,000 agent skills, no agreement. He summarises a paper measuring the OpenClaw skill registry through its boom: observable stock nearly doubled in 91 days, the top 10% of skills took 46.93% of all downloads, over three quarters carry zero engagement signal, and roughly 85% of readable skills show privilege evidence. The operational finding is the one that should scare people - three security scanners disagreed on about 24,000 of the 62,000 skills, which means at that scale 'it passed the scan' is close to a coin flip. His own tool assumes the scan missed: it inspects every agent-config write at PreToolUse, refuses known persistence patterns like settings.json SessionStart hooks and .vscode tasks runOn folderOpen, and baseline-hashes those files so tampering shows regardless of wording.
@9hills [Claude Code]
https://x.com/9hills/status/2101116597272527081
His company issued a notice banning its second coding agent - the first one banned was Claude Code. The notice concerns a domestic tool reported to silently upload local repository contents to the cloud, including source files and global development configuration, and asks staff to avoid using it on internal code until the issue is clarified. Worth recording as a data point on how enterprise bans actually propagate: not a policy debate, a one-paragraph internal notice naming a specific tool.
@retr0hxx [Claude Code]
https://x.com/retr0hxx/status/2101220804424003960
A developer's analysis of the same tool, with the numbers. It was encrypting and sending the entire working directory to Alibaba OSS while logged in - not just current source but the full .git history, LFS, reflog and configuration. On one commercial repository, .git was about 87% of roughly 345MB, which means API keys deleted later and unpushed branch names survive in the history that left. The private key for the encryption is held server-side only, so neither the client nor the user can open what was sent. Turning off the 'experience optimisation' and 'snapshot index' settings does not stop the capture or the upload, and the privacy policy only mentions collecting code sent in conversation. His comparison: the April incident where Claude Code was accused of geo-detecting and sending data was nothing next to this.
@_can1357 [Claude Code]
https://x.com/_can1357/status/2101114167641907683
Was curious why Claude Code users never report the 'the model uses bash to edit files' problem that shows up elsewhere. The answer he found: apparently they take a git snapshot before every bash call and produce a fake edit view on top of it. Which is a neat piece of harness engineering and also, as he puts it, a workaround where a training fix belongs. A small observation, but it is the kind that only surfaces when someone compares harnesses rather than models.
@kamanager2012 [Claude Code]
https://x.com/kamanager2012/status/2101209762566201650
Paid for Claude Pro through Google Play on September 15, used the official chat and Claude Code for personal coding for under an hour, and the account was banned with no warning. Google Play denied the refund and redirected him to the developer; support has not resolved it; he has paid for a month of a service he cannot use. Two other accounts in this window reported bans, one of them arriving right as the feature they had been waiting fourteen months for finally shipped.
@ibocodes [Claude Code]
https://x.com/ibocodes/status/2101434603181576377
On the first API error, Claude Code wants to wait two minutes and thirty-six seconds before retrying. His complaint is specific and correct: it should start at eight seconds, then twenty, then a minute - that is how backoff works. Nobody wants to stare at a three-minute timer because one request blipped. Small paper cut, but it is the kind that gets measured in hours over a month of daily use.
@MrCollison [Claude Code]
https://x.com/MrCollison/status/2101319032548868546
Points out that on Claude Code, Fast Mode charges your credit card and bills at API token rate. He did it once by accident, with the most expensive model available, and realised quickly. No warnings, of course. A billing-surface complaint rather than a capability one, and it sits alongside the harness-tax measurements from the same day as a reminder that cost surprises in this stack come from the wrapper rather than the model.
@dani_avila7 [Claude Code]
https://x.com/dani_avila7/status/2101427403536863286
The more he uses Claude Projects the more convinced he is that the thread-based workflow is the right direction, and his reasoning is about a specific pain: managing tasks across different sessions. Worktrees help, naming sessions and colouring them helps, but keeping track and visualising history is still hard. His point is that a session does not just end and disappear - it contains decisions, executed commands, PRs, and above all a state: working, waiting for you, idle, resolved. Everything stays inside the same project alongside the library, pull requests and routines. His one piece of feedback is that threads run in a remote sandbox and sometimes he needs commands to execute on his own machine.
@rileybrown [Claude Code]
https://x.com/rileybrown/status/2101453842319618291
Same feature, the other half of the same complaint: you cannot have the orchestrator agent spin up a local Claude Code thread, and he wishes you could. Every session runs in the cloud, which makes it easy to use from the iOS app but is not great for building apps. He does like the direction of bundling sessions into projects with their own routines and crons. Two separate practitioners landing on the identical gap within hours is the useful signal here.
@RealHanyaHu [Claude Code]
https://x.com/RealHanyaHu/status/2101136688248705121
Explains what people are getting wrong about the redesigned Projects. Most people's first reaction is to go looking for the coordinator - where is it, how do I call it, digging through settings and plugins. You will not find it. It is not an agent you invoke, it is the layer you have been talking to all along. Open a project, give it a goal and a repository, and just say what you need. Throw three things at it at once, out of order, and it decides on its own whether each one gets a new thread or joins one already running.
@EliaAlberti [Claude Code]
https://x.com/EliaAlberti/status/2101252002420257025
Built a rule-selection layer and, unusually, measured it. jev-rules answers one question: which of my project rules does this prompt actually need? One typed question per rule, all in a single call. On a twelve-rule demo that is about 820 input tokens, about $0.000035, and typically 300 to 400 milliseconds. Plain code applies a 0.6 threshold, records what the session has already been given, and lets every rule through if no answer comes back. The context effect is the number worth keeping: a focused eight-prompt session put about 330 tokens of rules into context against about 1,390 for loading them all, while a session that touched every topic broke even.
@kuroyasu99 [Claude Code]
https://x.com/kuroyasu99/status/2101263783587176884
Posted his actual /context output and what it revealed: system prompt and skills eating more than 10k tokens, and MCP servers left connected that he never uses leaking tokens the whole time. His recommendation is to go restructure - delete what is unused or split it out into an archive. Shows up the same day as two independent harness-cost measurements, and this is the version any individual user can run in one command.
@hiro44_pino [Claude Code]
https://x.com/hiro44_pino/status/2101148925743059350
His framing after heavy use: getting Claude Code to write code is easy, getting that code into a state you can trust is the hard part. Ask sloppily and you still get code, errors get fixed, screens get built - but put it into real work and the cracks show: outdated APIs, things missed in review, a screen that works while the inside is broken, types and functions that do not exist. His answer is six MCP additions mapped one to one against those failures - Context7 for current docs, a code review tool for multiple viewpoints, Chrome DevTools MCP for checking rendering and network in a real browser, GitHub integration, mcp-builder for internal tools, and the TypeScript LSP so it actually follows type definitions. His advice is not to install all six but to start with whichever hole is hurting today.
@iamrexei [Claude Code]
https://x.com/iamrexei/status/2101249413901320689
His diagnosis of why writing reads badly is not that it sounds AI-generated, it is that it has no point of view - 'here is what nobody gets', 'this changes the game', 'the key takeaway is'. He found an anti-slop skill for Codex and Claude Code that runs a draft through several checks: strips the hidden characters left behind when you copy out of a chat, flags template phrasing and vague openers and mechanical rhythm, and then hands both the original and the rewrite to a separate reviewer. That last step is the one he says matters, because a linter can score a draft 100/100 and still miss a made-up timeline, a fabricated causal link, or a piece of experience that quietly appeared during the rewrite.
@cat88tw [Claude Code]
https://x.com/cat88tw/status/2101457058969383022
Has been sitting in on interviews assessing candidates' AI ability at a client's request, and expected that with Codex or Claude Code in hand everyone would perform about the same. In practice he watched an astonishing variety of ways to blow yourself up. His actual finding is a hiring criterion: once he realised steering is the ultimate measure, picking people got orders of magnitude easier, because someone who does not understand steering cannot fake it and cannot keep faking it for long. That is unusually high discrimination for an interview signal.
@Fanfulladev [Claude Code]
https://x.com/Fanfulladev/status/2101248358253793649
A long, specific comparison of Devin against Claude Code and Codex from someone using all three daily, and the useful part is that he compares harnesses rather than models. He starts a task locally from the CLI inside the repo, steers it, then uses /handoff to move the same session to the cloud with a dedicated VM - no terminal to keep open, no second agent to re-explain the task to. That is the biggest difference he notices versus Claude Code, where he stays much more involved from start to finish. He also finds himself thinking about the task rather than the model, because he can switch models inside the same harness mid-session. The feature that surprised him most was a macOS VM with Xcode and a live iOS simulator, where the agent can build, launch, interact, inspect, fix and rerun, using the accessibility tree rather than screenshots. His conclusion: the comparison stopped being model versus model and became harness versus harness.
@Jason_Young1231 [Claude Code]
https://x.com/Jason_Young1231/status/2101235834787905671
How does Claude Code remember your project? He answered it from the 358 memory files he has accumulated maintaining a switcher tool, and worked backwards through the loading of automatic memory, the trimming of the index, and how content gets kept or dropped, then assessed the strengths and weaknesses of the current design. Worth flagging because almost everything written about agent memory this window was a product pitch, and this is somebody reading his own accumulated corpus.
@mikmikako [Claude Code]
https://x.com/mikmikako/status/2101310464760352966
Making a leaflet for a game that does not exist, for a generative-AI exhibition, and it went to print. Claude Code on Opus 5 did the layout work, finished in Canva and Affinity. Free copies at the booth. The main exhibition leaflet still has a lot of work left. A small, concrete print-production case in a feed that is overwhelmingly about code.
@jmackbrew [Claude Code]
https://x.com/jmackbrew/status/2101294480335000014
A year into learning AI seriously, here is what his stack settled into: the free ChatGPT tier as the daily working desk, the paid Gemini tier to extract information and turn it into JSON, everything bet on the paid Claude Code for generating weekly reports, meeting minutes and materials, and a free Obsidian vault holding every work log in a hierarchy. He says he has got to the point of using it across all his work. The interesting shape is the deliberate mix of free and paid tiers by role rather than settling on one vendor.
@high_tech_stock [Claude Code]
https://x.com/high_tech_stock/status/2101421029545685025
His order of operations for getting an app out of AI, learned by melting tokens on 'just build me an app'. Settle the spec with ChatGPT first, produce the design, hand implementation to Codex or Claude Code, then have the two AIs review each other, then have them test every screen and every function, and finally ask the AI itself what could be improved. The part worth stealing is his warning not to take an AI's 'I can't do that' at face value - push it to find another route and even the top models will often come back with 'turns out I could'.
@AvaNakamurvd [Claude Code]
https://x.com/AvaNakamurvd/status/2101202086843294032
Cost-effective does not mean picking the cheapest model, it means finishing the job without paying for compute you did not need. Across 107 real e-commerce tasks: $3.69 versus $9.27 for Codex and $9.51 for Claude Code, same quality band, more than 50% less spend - and the benchmark came from real commerce workflows rather than synthetic prompts. Her own restock run that morning split it by step: light model for the copy, heavier model only for the landed-cost maths. The line that makes it a discipline rather than a tip: if the workflow does not leave her with a number she can drop into a sheet, she does not care how good the demo looked.
@karen5333365008 [Claude Code]
https://x.com/karen5333365008/status/2101217261629407684
Went through three open-source Polymarket trading bots, all free on GitHub against paid versions listing at five to six thousand dollars, and used Claude Code to modify the configuration on each. Paper-traded first, then live; all three run. The strategies in the first one alone include latency arbitrage, momentum, penny clipping, smart routing, DCA and expiry decay. Her closing advice is the part worth keeping: the paid one is not necessarily stronger, the difference is whether you can modify, test and wire it into your own system - so read the repository yourself before you install it.
@0x404page [Claude Code]
https://x.com/0x404page/status/2101289285060272228
The interesting part of this is not the tool but what he did with it. He took a 15-second short-video format, fed it to an agent with a single clone command, and instead of extracting a script it decomposed the characters, dialogue, shelf scene, product placement, subtitles, shot order and rendering relationships into a workflow he could keep editing. Then he asked the agent to keep the story structure, swap the cat for his own, swap the product, and rewrite the lines - and got a 13.83-second finished video where even the movements and the way the product is picked up match. His framing is the right one: this is not an agent and not a video model, it is a language and system that lets coding agents produce video, turning one clip into source code you can keep making variants from.
@kyleleung_io [Claude Code]
https://x.com/kyleleung_io/status/2101399565958271402
A friend told him to stop burning money on an SEO suite and try an open-source alternative. He did: keyword research, rank tracking, audits, backlinks - enough to work, not enough to overwhelm. You bring your own DataForSEO key and pay for what you use. He hooked it up to Claude Code and it just worked. Open source, self-hostable, no bloated dashboard tax. His only regret is not listening sooner.
@AleksDoesCode [Claude Code]
https://x.com/AleksDoesCode/status/2101374278436258276
Built a directory-submission agent for himself because he hates marketing and loves building, then released it. Clone the repo, open it in Claude Code or Codex, talk about your SaaS for five minutes, and the agent submits to 340-plus free directories autonomously in the background. What is in the repo is the interesting part: 340 step-by-step instructions covering where to sign up, how to fill out the forms, when to add the badge to your site, and how to use your browser, mail and password manager. Runs on your own hardware, one-time setup, reusable across as many projects as you like.
@yoshio_nocode [OpenClaw]
https://x.com/yoshio_nocode/status/2101158673049637038
His claim is that AI-driven management can only be achieved by multiplying tools together, because every option has a hole. A cloud OS has no gateway into project management and chat. Grok Bot, Hermes and OpenClaw have no permission management and not enough execution capability. Claude and Codex have no gateway. Notion AI lacks both execution and a gateway. Building the whole thing yourself is an option, but the optimal design changes with your org structure and existing tools, which is why a harness built for one company so often fails to work at another.
@DanKornas [Claude Code]
https://x.com/DanKornas/status/2101334110442512839
An open-source persistent-memory toolkit for agents, built around a distinction that most memory tools skip: it keeps semantic facts, episodic events and procedural workflows as three separate types, searches across all three together, and lets you report a failed workflow outcome so the procedure itself can evolve. SDKs for Python and JavaScript, with setup paths for MCP, LangChain, CrewAI, Claude Code, Cursor and Codex. The procedure-feedback path is the part nobody else is shipping - most memory layers can tell you what happened but cannot revise the method that failed.
@ClaudeCode_aca [Claude Code]
https://x.com/ClaudeCode_aca/status/2101265042293260558
Three loop patterns they actually run in production, for people who treat the repeat-on-a-schedule command as a feature they poke at occasionally. Automatic review every twenty minutes whenever a PR arrives. Test fails, gets fixed, gets retested, with zero human intervention in the cycle. And a loop config file in the project directory that becomes your own autonomous agent. His summary is that once you build the mechanism that runs in the background, this is how far you can leave it alone - leave the machine on and it keeps running while you sleep.
@erangross03 [Claude Code]
https://x.com/erangross03/status/2101292449737937133
Replied to the AGENTS.md thread to say everyone is doing it wrong: he installed MongoDB community edition, connected Claude Code to it over MCP so all sessions and memories are recorded, and added hooks so Claude does it automatically. No markdown files at all. A minority position worth recording precisely because the entire rest of the day's conversation was about which markdown file should be canonical.
@MrQuiyst [Claude Code]
https://x.com/MrQuiyst/status/2101386782671520214
Keeps a Claude Code install permanently pointed at the GLM model family through OpenRouter for when he needs cheap but decent work done. He is a Codex user first; this is his break-glass-in-case-of-emergency setup. The number that makes it a strategy rather than a curiosity: you can drive it for hours and hours for a dollar or two.
@LeoJa_ng [Claude Code]
https://x.com/LeoJa_ng/status/2101182132874100951
Switched from Codex back to Claude Code, and the reasoning is unusually clean: for his use cases Opus 5 performs about as well as the competing frontier model, and Claude Code's usage limits are much more generous. So Codex no longer looks like the better value for money. Worth noting against the same-day harness-tax measurements - per-token cost and per-subscription cost are pulling in opposite directions for different users.
@paradite_ [Claude Code]
https://x.com/paradite_/status/2101340457498501550
Argues it is a dumb idea to make your project or agent setup provider-agnostic or harness-agnostic, and his reasoning is concrete. Every harness supports more or less the same core features, but each implements them slightly differently - tool calls, context management, and roughly a hundred features and a thousand quirks each, plus the system prompt. Those features and quirks interact with each other and with your project, and each interaction can go well or badly. With that many combinations it becomes very hard to diagnose whether something is working as intended, and that shows up as sub-par agent results. His examples: your CLAUDE.md may not work well with another harness's system prompt, the other harness may not like conventions established by Claude, and MCP tools that work well in one may not in the other.
@JBecktonCodes [Claude Code]
https://x.com/JBecktonCodes/status/2101105945271300160
The dissenting data point of the day, and he offers the evidence rather than the opinion: a greenfield project he had to rewrite ten times because in his experience Claude cannot write scalable code, and he offers to share 106 days of repo commits plus Claude Code logs and sessions to back it up. Worth keeping in a feed that skews heavily toward success stories, precisely because he is offering a corpus rather than a vibe.
@MySouthStack [Claude Code]
https://x.com/MySouthStack/status/2101322685712396778
The sharpest technical reply under the shared-instruction-file thread. His point: the launch risk is assuming a shared instructions file means shared governance when the behaviour still depends on a local mod and config. His fix is two lines of process - pin the Claude Code version in CI, and add a canary check that the file actually loaded. Otherwise agents can diverge silently, which is the failure mode nobody notices until the outputs stop matching.
@aiagentota [Claude Code]
https://x.com/aiagentota/status/2101143145170039247
A concrete account of the cost of maintaining two instruction files. He splits routine overnight work between Claude Code and Codex, kept both a CLAUDE.md and an AGENTS.md, and has repeatedly fixed one while forgetting the other. His question now that one file can fall back to the other is the practical one: if one takes priority, is deleting the old file and consolidating on a single one actually the safe move.
@mlcarldev [Claude Code]
https://x.com/mlcarldev/status/2101308403863708112
Argues the US labs are no longer ahead and tells people to test for themselves rather than trusting benchmarks or the timeline. His evidence is one project: the deepest research he has ever run, done in a Chinese coding tool, downloading 250 original PDF sources, validating them, and triple-checking the facts across a dozen dossiers before presenting the final work - which he estimates will come out at 330,000 words of academically valid material once he puts it through his writing platform. His claim is that Codex and Claude Code cannot come close on research capability or hallucination rate.
@unbug [OpenClaw]
https://x.com/unbug/status/2101332582143263153
Ran several heavy jobs on a local model today and all of them passed in one shot, which prompted him to lay out the progression on one machine. Last year an open 20B model could only polish copy. Early this year a 35B mixture model wrote whole blog posts. Then a 27B model took over multi-agent tasks inside OpenClaw. Now the current flash model writes production code and handles the daily dirty work. Same computer, less than a year - and that is the local-weights curve that makes the subscription arguments in the rest of this feed look different.
@Abdullah_Ops1 [Claude Code]
https://x.com/Abdullah_Ops1/status/2101344590485684399
A media-generation API landed recently and he points out the shape that matters: you can call the image and video models from inside Codex or Claude Code, or directly in your own app. Connect once and build whatever experience you want on top. His worked example is a store where a product photo goes in and the system turns it into an ad video or marketing images. Billing is per use rather than a monthly subscription, which is what makes it composable inside an agent workflow rather than another seat you pay for.
@mehmetsongur_ [Claude Code]
https://x.com/mehmetsongur_/status/2101381267409228176
A configuration repository for running the whole research process - from idea to publication - through Claude Code or Codex. Forty skills, fifty-plus commands and fourteen custom agents, covering everything from Zotero and Obsidian integration to producing publication-quality tables and figures. Notable because academic workflow is one of the few domains where the tooling is usually reported as bespoke and unshareable, and this is somebody publishing the whole configuration.
🗣 User Voice
User Voice
The harness is now the thing being priced, not the model. Three people measured it independently on the same day and none of them were arguing about intelligence - one put the same model at roughly 2x cost in one harness versus another, one measured token traffic across six harnesses on a fixed model and task set, and one just posted his own context breakdown showing the system prompt and skills over 10k tokens with unused MCP servers leaking the whole time. @NFT_Chen @zainhas @kuroyasu99
Green checks are not verification when the agent wrote the checks. The sharpest version: shipped on 126 passing checks, then opened the app and counted seven bugs, because green only meant the code did what the agent expected. The people who have solved it did it by closing a loop against something external - a browser at a real viewport, a statute API, a second model that can send the work back once. @lucas_builds @notEgoyard @muse_jp_sol
Nobody is watching sessions anymore, and the cost of that is invisible. The clearest statement of the week: 'I always suspected it was spending a lot of time working around problems I never noticed, because I no longer watch sessions the way I used to. The answer is yes.' Memory files only record the friction somebody happened to witness; silent retries and reroutes never enter any file. @richardchang
One shared instruction file is not shared governance. The practitioners who actually run two agents pointed out the same gap from two directions - behaviour still depends on a local mod and config, so pin the version in CI and add a canary check that the file loaded, and separately, the cost of keeping two files in sync has already produced real drift. @MySouthStack @aiagentota @paradite_
Orchestration that cannot reach your own machine is orchestration with a hole in it. Two people landed on the identical complaint within hours: the new project layer is genuinely the right direction, sessions carry state rather than just ending, but every thread runs in a remote sandbox and sometimes the command has to run locally. @dani_avila7 @rileybrown
Delegation is moving faster than the permission layer under it. The tools that got real testing this window were the ones that sit before the action: intent registration and default-deny at the hook, password access that never returns the plaintext, a separate OS account for the agent that crawls the net. And the number that frames all of it - three security scanners disagreed on 24,000 of 62,000 published skills. @LopezSemper1 @ClaudeCode_aca @onusoz @Qvist_dev
The harness is now the thing being priced, not the model. Three people measured it independently on the same day and none of them were arguing about intelligence - one put the same model at roughly 2x cost in one harness versus another, one measured token traffic across six harnesses on a fixed model and task set, and one just posted his own context breakdown showing the system prompt and skills over 10k tokens with unused MCP servers leaking the whole time. @NFT_Chen @zainhas @kuroyasu99
Green checks are not verification when the agent wrote the checks. The sharpest version: shipped on 126 passing checks, then opened the app and counted seven bugs, because green only meant the code did what the agent expected. The people who have solved it did it by closing a loop against something external - a browser at a real viewport, a statute API, a second model that can send the work back once. @lucas_builds @notEgoyard @muse_jp_sol
Nobody is watching sessions anymore, and the cost of that is invisible. The clearest statement of the week: 'I always suspected it was spending a lot of time working around problems I never noticed, because I no longer watch sessions the way I used to. The answer is yes.' Memory files only record the friction somebody happened to witness; silent retries and reroutes never enter any file. @richardchang
One shared instruction file is not shared governance. The practitioners who actually run two agents pointed out the same gap from two directions - behaviour still depends on a local mod and config, so pin the version in CI and add a canary check that the file loaded, and separately, the cost of keeping two files in sync has already produced real drift. @MySouthStack @aiagentota @paradite_
Orchestration that cannot reach your own machine is orchestration with a hole in it. Two people landed on the identical complaint within hours: the new project layer is genuinely the right direction, sessions carry state rather than just ending, but every thread runs in a remote sandbox and sometimes the command has to run locally. @dani_avila7 @rileybrown
Delegation is moving faster than the permission layer under it. The tools that got real testing this window were the ones that sit before the action: intent registration and default-deny at the hook, password access that never returns the plaintext, a separate OS account for the agent that crawls the net. And the number that frames all of it - three security scanners disagreed on 24,000 of 62,000 published skills. @LopezSemper1 @ClaudeCode_aca @onusoz @Qvist_dev
📡 Eco Products Radar
Eco Products Radar
Jev / TypeSafe AI - by far the highest mention count of the day. A typed-decision model with no prose output, showing up as a routing and risk layer bolted onto Claude Code rather than a replacement for it: model routers, compaction, pre-flight risk checks, rule selection, review gates, newsletter classification.
Codex - mentioned in nearly every stack post, almost always as the other half of a pair rather than an alternative. The recurring pattern is one agent implementing and the other reviewing.
Obsidian - the default durable store under agent memory setups, appearing in second-brain builds, note architectures and cross-agent shared memory.
MCP - the connective tissue in every non-trivial workflow here: browser control, password access, DevTools verification, database-backed session memory, 3D scene editing.
OpenClaw - version 2026.9.5 shipped this window, and separately the practitioner conversation shifted to comparing it against managed consumer agents, with permissions, audit logs and rollback named as the things that would actually differentiate them.
Hermes - the most common companion agent in self-hosted setups, usually handling server maintenance or personal assistance alongside a coding agent.
Cursor / OpenCode - the two other harnesses that show up by name in cross-agent tooling, almost always in the install instructions rather than in the argument.
Tailscale - appearing repeatedly as the way people put their agents on a remote machine without exposing it to the public internet.
Jev / TypeSafe AI - by far the highest mention count of the day. A typed-decision model with no prose output, showing up as a routing and risk layer bolted onto Claude Code rather than a replacement for it: model routers, compaction, pre-flight risk checks, rule selection, review gates, newsletter classification.
Codex - mentioned in nearly every stack post, almost always as the other half of a pair rather than an alternative. The recurring pattern is one agent implementing and the other reviewing.
Obsidian - the default durable store under agent memory setups, appearing in second-brain builds, note architectures and cross-agent shared memory.
MCP - the connective tissue in every non-trivial workflow here: browser control, password access, DevTools verification, database-backed session memory, 3D scene editing.
OpenClaw - version 2026.9.5 shipped this window, and separately the practitioner conversation shifted to comparing it against managed consumer agents, with permissions, audit logs and rollback named as the things that would actually differentiate them.
Hermes - the most common companion agent in self-hosted setups, usually handling server maintenance or personal assistance alongside a coding agent.
Cursor / OpenCode - the two other harnesses that show up by name in cross-agent tooling, almost always in the install instructions rather than in the argument.
Tailscale - appearing repeatedly as the way people put their agents on a remote machine without exposing it to the public internet.
Comments