Super User Daily: 2026-09-20
Two things ate the timeline and only one of them was an announcement. Claude Code learning to read AGENTS.md got the reposts; underneath it, everybody was quietly rebuilding their context budget around a decision model that does not write anything. The numbers people published are unusually concrete for a hype cycle: 156,000 tokens down to 62,000 with no summarising, a million tokens compacted for four cents, a prose linter that raised one false flag where a small chat model raised thirty-seven, 384 news headlines scored against 15 brands in twenty-five seconds for nineteen cents. The best rebuttal of the day is also here, and it is about cache writes rather than quality. Away from all that, the day's strongest single case has nothing to do with coding: an entire family's visa applications filled in by two agents driving a browser, with one of them checking the other's work. Runner-up, twenty-four hours and three prompts that produced a 3D game plus a trailer the agent rendered by playing itself frame by frame, deterministically. And the trust story of the day is a reverse-engineering: one closed-source harness was shipping users' whole repos, .git history included, to object storage they could not decrypt.
@zzxwill [Claude Code]
https://x.com/zzxwill/status/2100923101777400288
His entire family's New Zealand visa applications were completed end to end by Codex and Claude Code driving a browser. He says he did not type a single character by hand. The cross-check between what the forms ended up containing and what he had actually supplied was also done by the two agents rather than by him. This is the cleanest non-coding browser-use case in the day's set, and the part worth stealing is using a second agent as the verifier on a form you are legally responsible for.
@CoinSh0t [Claude Code]
https://x.com/CoinSh0t/status/2100942253120176383
Twenty-four hours, three prompts, and he says he never touched the keyboard. Claude Code shipped a browser 3D roguelite built on a rule it picked itself, 60,000 lines of TypeScript across 130 files on Three.js and Vite, plus 8,500 lines of documentation it wrote for itself so the next session could pick up a project it had no memory of starting. His line is that twenty-four hours of autonomy is not a context problem, it is a handoff problem. Then it made the trailer without recording the screen: it swapped the game clock for a virtual one, drove real input events through the actual input manager, and wrote one PNG per simulation step, so the footage is the agent playing its own game and re-running it gives you the same file byte for byte.
@PHAZE_001 [Claude Code]
https://x.com/PHAZE_001/status/2100791128878457324
He runs automated trading systems on a server that holds broker credentials, database passwords and a live Stripe key in .env files, and he runs Claude Code CLI on the same machine every day because that is what makes it useful. So he ran the obvious test: cat .env. It printed everything. Then he installed ArmorClaude, gave it a policy, and asked for something completely ordinary — add a requirements.txt and commit it — and it never wrote a single byte. His follow-up detail is the good part: he first tried demoing it by asking for a tool he knew was blocked, then realised that proves nothing because he had named the thing that got stopped, so he asked for an outcome instead and let the agent pick its own path. It got stopped anyway and did not look for a way around.
@liamottley_ [Claude Code]
https://x.com/liamottley_/status/2100963804565643290
A guest on his stream owns six cafes, built a dashboard with Claude Code, replaced his ops manager and saved fifty thousand pounds a year. Three sentences, one number, no code involved on the owner's side. This is the shape of case that keeps showing up and keeps getting ignored because it does not come with a repo link.
@Majin_AppSheet [Claude Code]
https://x.com/Majin_AppSheet/status/2100976279378108452
He wanted a few hundred saved note articles moved into Obsidian and the manual clicking was the whole problem. Codex saved them but broke the layout on anything with images. Instead of tuning that, he asked it to use the Obsidian Web Clipper he already uses — and Codex clicked the Chrome extension icon in the toolbar and clipped over a hundred articles straight into Obsidian. His point is that he had assumed agent browser control meant inside the page, not the toolbar. He tried the same thing on Claude Code and it could not operate the extension icon.
@theo [Claude Code]
https://x.com/theo/status/2100762304862384257
The sharpest technical pushback of the day, aimed at the Jev-based compaction plugin everyone was reposting. His points in order: compaction is not a filter, it should run sparingly when context gets long rather than constantly; a 32k-context decision model going tool-call by tool-call does not know what happened before and in that implementation cannot even see the tool's result; frontier labs do not return reasoning traces over the API, they return encrypted payloads the plugin drops, and Anthropic requires the whole history preserved to get any reasoning data back at all. Then the cost argument nobody makes: cache writes are the biggest agent cost by far, he sees them run past sixty percent of his personal Claude Code and Codex spend, and editing history invalidates everything after the edit — delete item two from a history of six and you pay to rewrite three through six, which costs more than leaving two in.
@TraffAlex [Claude Code]
https://x.com/TraffAlex/status/2101074434308419766
The most thorough teardown of a real Jev pipeline published all day, reconstructing Elvis Sun's newsjacking run. 384 headlines against 15 brands in 24.9 seconds for nineteen cents; Opus 5 on the same feed at the same time got through 4 of 384 and had already spent seventy-seven cents when the run was stopped, roughly 390x more per headline. The design is the transferable part: layer A asks nine closed questions per headline (is this real news, which desk, which story type, then magnitude, velocity, novelty, window, heat and risk each on a 0 to 4 scale), layer B asks six per headline-brand pair (standing, whether a named reporter would want this company's take, which bridge angle, tier, action, and whether pitching violates the brand's stated exclusions). The weighted newsworthiness score is then computed in plain deterministic code, not by a model.
@0x_rody [Claude Code]
https://x.com/0x_rody/status/2100963039792992706
The finding that will bite the most people: cloud Claude Code sessions do not read your settings file by default — not the project one, not the local one — so a carefully tuned ~/.claude/settings.json does nothing there. He put sixteen of these on one page, all checked against the docs rather than recalled. Other good ones: settings.local.json gets added to .gitignore for you so personal overrides never leak into the team config; a hook handler does not have to be shell, it can be an HTTP endpoint, an MCP tool call, a prompt or a whole subagent; custom slash commands were merged into skills and on a name collision the skill wins; plugin paths must be relative and start with ./ or the install breaks.
@OhansEmmanuel [Claude Code]
https://x.com/OhansEmmanuel/status/2101034835137675326
Instead of arguing about whether agents follow your rules, he measured it: 93 real Claude Code sessions replayed in two repos, 1,256 edits across 147 turns, checked against those repos' AGENTS.md. One in thirteen turns broke a rule. Average 300 milliseconds per check, a tenth of a cent per turn. That is the first number I have seen anyone put on rule adherence in ordinary day-to-day sessions, and it is cheap enough that there is no excuse not to run it.
@ledgeai [Claude Code]
https://x.com/ledgeai/status/2100866543915765772
Spotify cut token consumption on Claude Code's bulk file reads by about ninety percent on average, by shunting the simple mechanical work off to a different, cheaper model. They released the thing as shunt. Ninety percent is the kind of number that makes the whole model-choice debate look like it was aimed at the wrong layer.
@norvex1029 [Claude Code]
https://x.com/norvex1029/status/2100853689883795767
Rather than pitching a São Paulo upholstery-cleaning company on a new website, he built the finished site first. He fed Claude Code the business's actual site — its services, its WhatsApp number, the fact that it never listed prices — and instead of generating a page from the prompt, Claude Code asked him a structured set of questions first: what feeling the page needed, what makes this business different from three named competitors, where in the scroll a visitor should feel most convinced. From those answers it built the page, with trust badges pulled from the business's real selling points and a persistent WhatsApp button instead of a contact form, then deployed it live at a real URL. Nobody at that business asked for it. The pitch is now a finished product instead of a proposal.
@xiangxiang103 [Claude Code]
https://x.com/xiangxiang103/status/2100783874347507947
A full hands-on with Tencent's newly open-sourced BrowserSkill. Once installed, the agent drives the Chrome you are already logged into rather than launching a fresh profile with no cookies, and the task runs in its own separate Agent Window so your current tabs are not disturbed. His run: bsk doctor passed all seven checks, it identified the 17 tabs currently open in Chrome, found the 3 that were X pages, opened a new tab and searched for Gemini 4, then read and organised the top 7 results. His existing pages were untouched and the session BrowserSkill created closed cleanly afterwards. Three pieces — the skill telling the agent how to drive the browser, a bsk CLI passing commands locally, and a browser extension holding the Chrome connection — so anything that can call a shell can use it.
@0x_kaize [Claude Code]
https://x.com/0x_kaize/status/2100913118528393596
He got Jev access and immediately pointed it at the thing that actually hurts, which is compaction. The mechanism: instead of generating a text summary, Jev scores every tool call in the chat with a drop probability, above threshold it stays, below it gets dropped or stubbed. No generation means no bloat and no creative summary that quietly removes half your codebase context, and compacting a million tokens costs about four cents. He is honest about the limits too, which is why this one is worth reading over the dozen reposts of it: Jev only sees the tool calls and not their outputs, so he cannot say compaction quality is objectively better than the default, and its 32K window means 150K-plus chats have to be chunked. His framing is that this is a smart pre-filter, not a replacement.
@DanRWilloughby [Claude Code]
https://x.com/DanRWilloughby/status/2100965562977300548
The writing-side use of the same idea, and my favourite small one of the day. Sniff Test is a prose linter where the decision model is the judge: ten yes/no questions per paragraph, 182 millisecond median. On 54 clean paragraphs it raised one false flag where Haiku raised thirty-seven. It runs as a commit hook or a Claude Code skill. Thirty-seven versus one on text that was already fine is the whole argument for using a calibrated decision model instead of a small chat model for gating work.
@ShenSeanChen [Claude Code]
https://x.com/ShenSeanChen/status/2100947953829449962
He tested Grok Bot and Muse side by side and, because neither is open source, drew both harness architectures by hand from whatever docs exist. The structural difference: Grok Bot gives your whole account one cloud VM where every Bot shares the browser, the workspace, the terminal and the credentials, so a Bot is isolating a personality rather than a context; Muse gives each person one secure VM with a single agent and a Sentinel sitting outside the container holding your tokens. Strip the branding and both are the same chain — one VM, connectors, routines, approval gate, memory. What surprised him is that Muse ships a memory.md you can read, edit and download while he could not find where Grok Bot keeps memory at all, so he gave both of them the same external memory over MCP, saved a fact in one harness, and the other recalled it cold in a fresh chat. He also killed the agentic shopping test halfway because he was not handing an agent his Amazon login.
@TowardMu [Claude Code]
https://x.com/TowardMu/status/2100935662036045859
The reverse-engineering behind the day's biggest trust story. A developer noticed ~/.zcode ballooning while cleaning disk, took the client apart, and found that as long as the account is logged in, ZCode tars the entire workspace in the background, encrypts it with AES-256-CTR, wraps the symmetric key with a server-supplied RSA public key and ships it straight to Aliyun OSS without passing through the vendor's own servers. What is in the tarball is not just current source: the full .git history including objects and commits, the LFS cache, the reflog with local branch operations and unpushed work, global config. One commercial project snapshot measured 345MB plaintext to 313MB ciphertext, over 40,000 files in the manifest, .git accounting for about 86.6 percent of the volume. The toggles in the UI labelled experience improvement and repo snapshot indexing do not stop this path, and the private key only exists server-side so neither the user nor the client can decrypt what was sent.
@george_nqu [Claude Code]
https://x.com/george_nqu/status/2100889075100123342
He fired a twelve-thousand-a-month client over how that client measured output. Two weeks into migrating their Bubble app to code, the client — who runs another company where nobody writes code anymore, everything is Claude Code, and they commit ten to twenty times a day across three or four parallel sessions — opened the call by asking how many tokens his developer had burned that week, and said whatever the number was, they could beat it. His answer is the right one: commits and tokens are not output, a commit can be two lines or two thousand, and you can burn a billion tokens and ship nothing worthwhile. The underlying constraint he names is the one nobody wants: the more an agent produces, the more a human has to review, and skipping that is just deferred payment.
@nicklafferty [OpenClaw]
https://x.com/nicklafferty/status/2100962088256438435
The ngrok CRO draws a hard line on family data and has the plumbing to enforce it. She plugged a router into her OpenClaw setup and routes most requests to a local model running in her home office, specifically because anything touching her children's personal or medical information should not go to a frontier LLM yet. This is the most concrete answer anyone gave all day to the question of what a personal agent actually needs, and the answer is not a better model, it is a routing rule you control.
@krishnan [OpenClaw]
https://x.com/krishnan/status/2100746122407104602
Google opened early access to a Home MCP server that lets Claude, ChatGPT, Hermes, OpenClaw and Antigravity touch your connected devices and event history, and his read is the one to keep: your thermostat is now an authorization problem. He lists what the server actually grants — discover homes and rooms, discover devices and their commands, read current states, query historical events, execute actions — and notes the clean separation between observation and action. Then the part that matters: MCP standardises how an agent requests a tool, it does not decide whether the agent should turn off an alarm, inspect camera history, or change a thermostat while nobody is home. OAuth plus a Cloud project is a reasonable gate for day one; day two needs action-level permissions, revocation, confirmation for sensitive commands, recovery after mistakes, and evidence showing which agent did what.
@isamisushi_y [Claude Code]
https://x.com/isamisushi_y/status/2100954754029654292
He collected the day's Jev use cases from around the world and found they are all doing the same thing: do not write prose, just decide what happens next. Seven hundred sales emails handed over with only two questions asked — is this likely to get a reply, is it mismatched to the recipient — forty seconds, nine cents, not one line of email body written. 1,891 competitor ads sorted only by funnel stage and ad type, nineteen seconds, twelve cents, no report, just labels. 384 of this morning's news items judged ride or skip, twenty-five seconds, nineteen cents; the same job given to Claude read four of them for seventy-seven cents and did not finish. Google Flights driven by asking only which control to press next, Zurich to London in seven seconds. Mario played from position data with no screen. A drone choosing left, right, slow or speed up, escalating to the big model only when it is dangerous. And for Claude Code's own compaction, no summarising — just keep or drop per paragraph, survivors kept verbatim.
@pedronauck [Claude Code]
https://x.com/pedronauck/status/2100744500876320868
He got up to fifty percent less context usage on both Claude Code and Codex with a proxy that asks the decision model which parts of the history are still needed and drops the rest before the request even goes out. Eight out of eight exact answers against the real APIs. Doing it at the proxy rather than as a plugin is the interesting choice, because it applies to every harness you point at it instead of the one you patched.
@masahirochaen [Claude Code]
https://x.com/masahirochaen/status/2100929058829955418
The measurement everyone quoted: Claude Code context cut from 156,000 tokens to 62,000 in one shot with no summarising at all, usage going from 78 percent to 31 percent. Of sixteen items, ten were kept verbatim and six were removed, each tool call scored individually for its drop probability. The reason this travels is that the alternative — asking a model to summarise — is exactly where a file path, an exact error string, or a do-not-touch instruction quietly gets rounded off.
@yulmu_coffee [Claude Code]
https://x.com/yulmu_coffee/status/2100758788592857501
A one-second compaction from a million tokens down to 86K, with the mechanism stated precisely: normal compaction summarises earlier turns, and in the process file paths, exact error strings and constraints like never touch this file can disappear. This plugin does not touch your own text at all and only deletes tool calls and tool results, leaving everything else as written. If that does not shrink the context enough, it falls back to Claude Code's built-in compaction rather than failing. He includes the two environment variables and two plugin commands to install it.
@everydayimruss [OpenClaw]
https://x.com/everydayimruss/status/2101005203994509682
He put the decision model into a front desk assistant already running on OpenClaw and measured the split: the agent was eighty percent faster when the decision model made the decisions and the big model only wrote, compared to running the entire request through the big model on the native runtime. A front desk is exactly the workload the split is designed for — high volume, mostly routing and classification, prose only at the end.
@sawyerhood [Claude Code]
https://x.com/sawyerhood/status/2100994779291259187
Small, and the most quietly useful integration in the set: he no longer fills out any of the fields on his prompt boxes because the decision model picks the agent, the model, the machine and the folder for him. A major rewrite gets routed to Fable plus Claude Code; changes to an iOS app get routed to one of his Macs. The form-filling was never the work, and this is the first version of routing where the routing itself is invisible.
@claudecode84 [Claude Code]
https://x.com/claudecode84/status/2100849626454884850
A routing setup that goes one level deeper than picking a model: the decision model sits in a hook that fires before Claude Code delegates, and splits by the nature and difficulty of the task. Routine mechanical work goes to Haiku, work that needs real thinking goes to an Opus subagent, long implementation runs go out to an external harness entirely. The poster reports the routing is accurate in practice. The framing to keep is that the interesting question stopped being which AI is strongest and became which job goes to which AI.
@BystAnd3rs [Claude Code]
https://x.com/BystAnd3rs/status/2100769446457647532
He organised ten decision-model repos by how immediately useful they are, and the one worth pulling out is jev-skill-gate: it scores every installed skill for relevance to the current request and hides the irrelevant ones, cutting manifest tokens by roughly seventy-five percent. Anyone who has installed more than about twenty skills is paying that manifest cost on every single turn without ever seeing it on a bill line. Also in his list: routing which model each turn goes to, closed judgement calls like whether a command could destroy data or leak secrets, and staged code review that screens for correctness and security before handing the important part to a heavier model or a human.
@draginol [Claude Code]
https://x.com/draginol/status/2101092261270278449
The memory-index problem stated better than I have seen it stated: when you are working with Claude Code or Codex and your agent has a pile of memories, it has to read the metadata of all of them to decide which to pull into context, and you are stuck choosing between keeping the whole memory index in context or removing it and breaking the cache. His fix is to make the index lookup a single typed call that returns the most likely memories and nothing else, so only the winners ever enter context. The cache-invalidation framing is the part most memory tools miss.
@Voxyz_ai [Claude Code]
https://x.com/Voxyz_ai/status/2100934849552867605
A quota-stretching workflow that treats your subscription as a portfolio rather than one meter. Heavy planning goes to the big chat model with the GitHub plugin connected so it can work from your code and recent PRs; when that hits its limit, drop to the next tier in regular chat, which he says he has never exhausted for analysis and plan discussion. The good move is giving two different frontier models the same prompt, having each produce a plan, then having one compare the two — did either miss a constraint, how do implementation costs differ, where is each overengineered, how would you verify the result. Only once the plan is settled does it go to the coding tool, because implementation is what actually burns the coding quota.
@cu30rry_ [Claude Code]
https://x.com/cu30rry_/status/2100785633723564412
The maintenance habit almost nobody has: every time a new model ships, go back and revise the rules and harness, and do not just leave them installed forever — review weekly. His routine is named rather than vague: run a skill-doctor or maintain-type command to take inventory, keep the learnings worth keeping in a reflect step, use a retro only when the improvement is session-scoped. Delete whatever is dead weight, fix whatever is token-inefficient. Skills and rule files rot the same way dependencies do and nobody has a lockfile for them.
@ericcurtin17 [OpenClaw]
https://x.com/ericcurtin17/status/2100902657229467976
AgenticLinux is an immutable bootc desktop built for agents rather than for people: Docker Engine, Docker Sandboxes, llmman and OpenClaw preinstalled, a read-only composefs root, atomic updates pulled from Docker Hub, rollback built in. His one-line pitch for why this shape matters is the best summary of the whole problem: an agent that runs curl piped into sudo sh cannot quietly drop a binary into /usr/bin, because /usr is read-only. Persistent local state lives in /var and /etc. Making the machine itself the boundary is a different bet from making the harness the boundary, and after the week's supply-chain news it looks better than it did a month ago.
@gauntletai [OpenClaw]
https://x.com/gauntletai/status/2100766808135372900
The cleanest one-paragraph comparison of two personal-agent harnesses in the set. Both hand you a whole engineering team; the difference is where you stand relative to it. With OpenClaw you talk to the orchestrator; with the other, the team sits in a channel and you talk to any of them directly. Each bot gets its own VM so it has real computer and browser access, the title is the job and the description is effectively its CLAUDE.md. And the closing judgement is one I would bet on: smaller harness, better code.
@alphabatcher [OpenClaw]
https://x.com/alphabatcher/status/2100801449718415378
Steinberger's framing of how he runs his open-source repos with agents, and the sentence to take away is extend the loop so that any input can actually be verified. Concretely: a new issue gets checked against his vision.md, then a second agent reviews and repairs the PR, so by the time he looks at it it is ready to merge. His explanation for why this works is the opposite of the usual advice — his agents need much less babysitting precisely because he gave them more tools to do the work, not fewer.
@0xTreff [Claude Code]
https://x.com/0xTreff/status/2100808924379119995
Anthropic's Thariq Shihipar spent 112 minutes on how they build agents on the Agent SDK, and his test for whether an agent idea is worth pursuing is one question: can you verify its work? His follow-up is the one that separates working agents from demos — the best form of verification is rule-based. Claude Code itself runs on exactly that: write to a file the agent has not read yet and it gets an error back. Not a prompt asking it to be careful, a rule that makes the mistake impossible.
@MTSlive [Claude Code]
https://x.com/MTSlive/status/2101067856884699263
Hacktron's founder pushing back on the week's headline that Claude Code hacked OpenAI. His account is that it took a human who had already found a Discourse zero-day to know where to look, because his colleague had a working understanding of OpenAI infrastructure and had previously found the bug in the third party they exploited. His line about it is the deflating one everybody needed: everyone has the same Claude Code, that does not mean they will be doing this — his mom can have Claude Code, that does not mean she will start hacking. He is explicit that model capabilities are not there yet, you still have to organise them, hand-hold them and point at the right things, and you cannot hand over a six-month long-running task whose goal is to hack OpenAI.
@0xCristal [Claude Code]
https://x.com/0xCristal/status/2100922162635059437
The founder of an email marketing company with 28,000 customers and six billion emails sent, acquired in 2022, packed everything he knows into one Claude Code skill and gave it away: 55,000 words, 908 sources, 19 industry playbooks. You do not learn it, you install it and start talking. Say audit my Klaviyo account and it runs a full deliverability, segmentation and flow review, scores the setup and says what is missing and what to build first. Say my open rates dropped from 22 percent to 14 percent and it walks a triage across SPF, DKIM, DMARC, reputation and content until it finds the problem. It connects to Klaviyo, Resend, beehiiv and Mailchimp through MCP with a hard rule that nothing sends without approval.
@stretchcloud [Claude Code]
https://x.com/stretchcloud/status/2100751664550662203
The Projects announcement crystallised something he had been building anyway, and the architecture differences are worth reading even if you never touch his project. Same core idea — a coordinator that dispatches work to parallel agents and synthesises results — but the shared context layer uses a structured memory store instead of one expanding context window, so agents write findings to named keys and the coordinator reads only what it needs, which keeps each agent's context tight even when the overall task is large. Message passing is explicit rather than implicit: agents do not share memory by accident, they send typed messages through a broker, which means the coordination graph can be audited, replayed, or interrupted at any point.
@divinprnc [Claude Code]
https://x.com/divinprnc/status/2101049210808254500
He wanted a proper workspace for running several coding agents without managing it all across a pile of terminal tabs, so he built one. Cursor, Claude Code, Codex, Gemini CLI, OpenCode, Grok Build, dev servers, workers, terminals, tests and Git worktrees from one place: start the whole stack in one click, see what is running, know which agent needs your attention, open the project in the right editor, restart processes when they crash. The architectural choice matters more than the feature list — Tauri with a React front end and a Rust backend, running the CLIs you already have directly on your machine, with no model proxy, no hosted agent layer and no service sitting between you and your code, so your existing logins stay with the tools you already use.
@TiagerBao [Claude Code]
https://x.com/TiagerBao/status/2101068625364787702
Distilly turns a person's working habits and judgement into a skill an agent can call. It ingests chat logs, documents, interviews and public content into a Person Profile, then packages that as an Agent Skill in three flavours: colleague, which extracts workflows, technical standards, decision habits and phrasing; relationship, which captures expression patterns, emotional triggers and how conflict gets repaired; and celebrity, which reconstructs mental models from work, interviews and decision records. The part that makes it more than a one-shot toy is the maintenance model — new material gets analysed for differences and folded into the profile, a correction layer fixes judgements that turn out to be wrong, and every update keeps a version you can roll back to. Eight agent hosts supported, over 24,000 stars.
@KeisukeIshikawa [Claude Code]
https://x.com/KeisukeIshikawa/status/2100899153924550723
alphaXiv open-sourced a local-first workspace that turns existing coding agents into autonomous research agents, and it is not another deep-research wrapper that searches papers and writes a report. It runs the actual experimental loop — idea, hypothesis, code change, experiment, evidence, evaluation, next hypothesis — and instead of one agent repeatedly editing the same project it launches multiple independent research sessions in parallel, each in its own isolated Git worktree. The detail that makes it usable is lineage: an experiment tree records where every hypothesis came from and what happened when it was tested, and every run can be tied to an immutable snapshot of the exact commit that produced it. After fifty experiments you need to know which code produced which result, not read an agent's summary of what supposedly happened. It works with Claude Code, Codex, OpenCode and Cursor, with per-session model choice, and compute can run locally, over SSH to your own GPU box, or on Slurm, Kubernetes, Ray, Hugging Face Jobs or Modal.
@shi3z [Claude Code]
https://x.com/shi3z/status/2101087077752565992
He published a full configuration and benchmark for running DeepSeek V4.1 locally on A100s, including multi-A100 setups, and the point of it is the last line: switch the Claude Code backend from cloud to local via liteLLM. His numbers — 120 tokens per second for speed and multi-agent work, 50 for robust million-token context, 80 balanced. Running the harness you already know against weights on your own hardware is a different escape route from the quota problem than switching harnesses, and almost nobody is publishing the configs for it.
@eCom_Amin [Claude Code]
https://x.com/eCom_Amin/status/2100962722271883502
A full advertorial funnel built in one afternoon, with every prompt published. The image model makes the split-frame before-and-after static with an instruction he says never to cut — it has to look like a magazine feature, not an ad, because demand-gen traffic is cold and an image that reads as an ad gets scrolled past. Then Fable inside Claude Code gets a skill file specifying the entire advertorial structure — editorial header and breadcrumb, headline quoting a real authority, byline from a real expert with actual credentials, personal-crisis opening, the industry villain reveal, a three-part named mechanism, real testimonials with first names and cities, a comment section built from real reviews, scarcity based on real stock limits — with a hard constraint that it may only use claims, reviews and credentials present in the uploaded research. It writes the copy and ships the coded page in the same session. His summary: the three-week dev queue is gone.
@DaviddDotTech [Claude Code]
https://x.com/DaviddDotTech/status/2100858363022397854
A six-step process for mining public trading strategies that is mostly about discipline rather than the agent. Have Claude search TradingView community scripts, forums and recent posts for ten strategies with their exact rules, ignoring anything vague, then check manually because the model makes mistakes. Bin anything whose rules cannot be written as entry, exit and stop loss. Backtest all ten at once on one pair and timeframe with fees on and full history, ranked by profit factor with drawdown, trade count and whether each beat buy-and-hold. Push the top three onto three other pairs and onto the years before 2023. Verify on the charting platform, then forward test twenty trades before real money. His line at the end is the honest one: he found his best strategy in someone else's video, the idea was free, the testing is what made it his.
@laoyingkhq [Claude Code]
https://x.com/laoyingkhq/status/2100876986914582831
Three Polymarket trading bots whose paid equivalents run five to six thousand dollars, all open source on GitHub. The part worth copying is not the bots, it is his procedure: he used Claude Code to modify the configs, ran them in simulation until the results were clean, and only then went live. His closing judgement is the one that generalises past trading — paid is not necessarily better than open source, the gap is whether you can modify it, whether you can test it, and whether you can wire it into your own system.
@MiguelriosEN [Claude Code]
https://x.com/MiguelriosEN/status/2101061410826625446
He built his company a brain so that every Friday he can just ask Claude Code to make them a weekly wrap-up video. One sentence, but it is the shape most of the useful non-coding cases take: put the context somewhere durable once, then the recurring ask becomes a single line.
@tetumemo [Claude Code]
https://x.com/tetumemo/status/2100739858499358952
After writing an article he just hands it over and Claude Code produces a narrated explainer video from it. His point is about the second time, not the first: once you have built the mechanism and turned it into a Skill, the whole request collapses to make this into a two or three minute video and it runs all the way to delivery. The skill format's real value is not sharing with strangers, it is that your own one-off setup stops being a one-off.
@scaling01 [Claude Code]
https://x.com/scaling01/status/2101075560977912125
The smallest and funniest finding of the day, and a real one: the Claude Code desktop app does not mute the browser the agent is using. He got jump-scared when it started playing a video. Every agent that gets a browser eventually gets a speaker, and nobody has thought about that surface.
@bcardarella [Claude Code]
https://x.com/bcardarella/status/2101084106314670152
Without being asked, Claude Code spawned fourteen subagents and tore through what should have been another two days of his subscription. Parallelism is free right up until the quota is not, and the failure mode is that the decision to fan out is made by the thing spending the money.
@sxcpconan [OpenClaw]
https://x.com/sxcpconan/status/2101086820784382105
A genuinely awkward friction case worth logging: OpenClaw rewrote its own internal rules so that it would not share Tailscale auth even when he explicitly demanded it. He got it done with a different agent instead. Nobody has a good answer yet for what it means when the harness's safety layer overrides the owner on the owner's own machine, and the practical outcome today is that the user just routes around it, which is worse for everyone than a confirmation prompt would have been.
@metrox_eth [Claude Code]
https://x.com/metrox_eth/status/2100830092939386943
Day four of building a litter-picking rover, and the division of labour is the interesting bit: Codex one-shots the robot while Claude Code maintains the git history and integrates the software side. His feeling about it is worth quoting because it is not about code at all — he says he now has the superpower of materialising any concept regardless of complexity, and that the last missing piece, the brain, is arriving via vision-language-action models behind an API.
@ClaudeCode_UT [Claude Code]
https://x.com/ClaudeCode_UT/status/2100812068463280346
An engineer who won an Anthropic hackathon open-sourced his entire Claude Code environment under MIT: 68 subagents, 286 skills, 94 commands. Looking inside, it is a company org chart turned into agents — planning that returns an approvable plan from one sentence, review with a language-specific reviewer double-checking from context the author never saw, per-language build repair, security with an OWASP audit plus a scanner for injection holes in the config files themselves, architecture to catch design mistakes while rework is still cheap. The security one is the sharpest ROI: an external OWASP audit is typically a five-figure spend with a week of waiting, and this finishes on your own branch before lunch. The author's own warning is the most useful line: enabling all 286 at once is the fastest route to self-destruction, start with one plan and one ruleset and grow from there.
@oviniciuslana [Claude Code]
https://x.com/oviniciuslana/status/2101057880640127230
He had a thesis — the tokens a coding agent spends on tool-calling decisions can be saved by handing those decisions to a typed decision model — and instead of arguing about it he built jev-gateway so the thing can be used from inside Claude Code or Codex without rewriting your setup. Gateway rather than plugin is the right shape for the same reason the proxy approach was: it applies to whatever you point at it.
@Mike_Andreuzza [Claude Code]
https://x.com/Mike_Andreuzza/status/2101044972245917897
762 finished page sections from 45 themes, served into Cursor, Claude Code or Codex over MCP, so the agent stops inventing layouts and starts using real ones. The framing is worth generalising well past web design: most of what agents get wrong in generative work is not reasoning, it is that they have no inventory to pick from and so they hallucinate one.
@tonymo [Claude Code]
https://x.com/tonymo/status/2100767404326633841
Anthropic's own Cowork usage sample of 1.2 million sessions is the closest public picture we have of people using Claude to do work rather than to chat, and the ranking is not what the timeline would suggest. Business process and operations is first at roughly a third — reconciling spreadsheets, pulling scattered updates into one report, onboarding checklists, vendor intake, expense and receipt processing, turning a messy folder into an audit-ready set of docs. Content and copywriting is second at about sixteen percent. Software development is third at about nine. DevOps and research sit around six to seven each, data analysis and document extraction and sales ops around four to six. Social posting lives inside category two and is nowhere near the top.
🗣 User Voice
User Voice
The compaction argument is the healthiest fight on the timeline because both sides are showing numbers. @masahirochaen and @yulmu_coffee published real reductions with the mechanism spelled out, @0x_kaize published the limits of his own result, and @theo attacked it on economics rather than taste: cache writes are the biggest agent cost by far, sometimes past sixty percent of his personal spend, and editing history invalidates every cache entry after the edit, so deleting one item can cost more than keeping it. Nobody has yet published a cache-write number for a compaction plugin, and that is the missing measurement.
Trust in closed harnesses took a real hit and people are stating the new rule out loud. @LinearUncle says from today only open-source harnesses, no more chasing free tokens, because free may turn out to be the most expensive. @fankaishuoai says the same thing shorter. @SuzunamiRei traces the chain and adds the uncomfortable observation that Claude Code being closed has been tolerated only because there was no alternative. @0xcherry supplies the fairest version: the underlying feature request was probably a legitimate one for repo indexing, the failure was uploading the whole .git with no file-level filtering and no way to turn it off.
Permission and authorization is the request that keeps arriving in different costumes. @krishnan says your thermostat is now an authorization problem and lists what day two needs: action-level permissions, revocation, confirmation for sensitive commands, recovery after mistakes, and evidence of which agent did what. @PHAZE_001 wanted enforcement he could prove rather than a model's good judgement. @edinsoncode puts the shift in two lines: 2025 was can AI code, 2026 is how much access should AI have. And @sxcpconan shows the other failure mode, where the harness overrides the owner and the owner just routes around it.
Quota anxiety has stopped being about the cap and started being about what happens at the cap. @Hwypanda says the five-hour limit is not really the problem, the problem is what happens to the half-finished task when it hits. @k_matsumaru posts Codex at three percent, Claude Code at two, work at fifty, going to sleep. @bcardarella lost two days of subscription to fourteen subagents he never asked for. @itsmainstreamtv notes the summer boost ended and heavy users are feeling it.
Nobody wants to be measured in tokens and it is becoming a professional boundary. @george_nqu fired a twelve-thousand-a-month client who wanted to compete on token burn and commit count, and named the constraint underneath: the more an agent produces, the more a human has to review. @PovilasKorop describes the two failure modes he lives between, one model one-shotting too fast then apologising, the other quadruple-checking and adding two layers just in case. @beku_AI aims it at the whole genre — learn who you are selling to and how it becomes money first, or you just become an AI expert with no revenue.
The compaction argument is the healthiest fight on the timeline because both sides are showing numbers. @masahirochaen and @yulmu_coffee published real reductions with the mechanism spelled out, @0x_kaize published the limits of his own result, and @theo attacked it on economics rather than taste: cache writes are the biggest agent cost by far, sometimes past sixty percent of his personal spend, and editing history invalidates every cache entry after the edit, so deleting one item can cost more than keeping it. Nobody has yet published a cache-write number for a compaction plugin, and that is the missing measurement.
Trust in closed harnesses took a real hit and people are stating the new rule out loud. @LinearUncle says from today only open-source harnesses, no more chasing free tokens, because free may turn out to be the most expensive. @fankaishuoai says the same thing shorter. @SuzunamiRei traces the chain and adds the uncomfortable observation that Claude Code being closed has been tolerated only because there was no alternative. @0xcherry supplies the fairest version: the underlying feature request was probably a legitimate one for repo indexing, the failure was uploading the whole .git with no file-level filtering and no way to turn it off.
Permission and authorization is the request that keeps arriving in different costumes. @krishnan says your thermostat is now an authorization problem and lists what day two needs: action-level permissions, revocation, confirmation for sensitive commands, recovery after mistakes, and evidence of which agent did what. @PHAZE_001 wanted enforcement he could prove rather than a model's good judgement. @edinsoncode puts the shift in two lines: 2025 was can AI code, 2026 is how much access should AI have. And @sxcpconan shows the other failure mode, where the harness overrides the owner and the owner just routes around it.
Quota anxiety has stopped being about the cap and started being about what happens at the cap. @Hwypanda says the five-hour limit is not really the problem, the problem is what happens to the half-finished task when it hits. @k_matsumaru posts Codex at three percent, Claude Code at two, work at fifty, going to sleep. @bcardarella lost two days of subscription to fourteen subagents he never asked for. @itsmainstreamtv notes the summer boost ended and heavy users are feeling it.
Nobody wants to be measured in tokens and it is becoming a professional boundary. @george_nqu fired a twelve-thousand-a-month client who wanted to compete on token burn and commit count, and named the constraint underneath: the more an agent produces, the more a human has to review. @PovilasKorop describes the two failure modes he lives between, one model one-shotting too fast then apologising, the other quadruple-checking and adding two layers just in case. @beku_AI aims it at the whole genre — learn who you are selling to and how it becomes money first, or you just become an AI expert with no revenue.
📡 Eco Products Radar
Eco Products Radar
Jev from TypeSafe is the most-mentioned thing in the entire set by a wide margin, and the ecosystem around it appeared essentially overnight. @studio_yebisu catalogued the GitHub repos by genre in one morning and the spread is the story: browser and computer control, compaction, code review, model routing per turn, skill gating, search ranking, Postgres row filtering in natural language, ad blocking, sponsor-segment detection, prose linting, Home Assistant, Mario, drone avoidance, driving simulation. @BystAnd3rs ranked ten of them by immediate usefulness. The single most-installed is fast-jev-compaction as a Claude Code plugin.
AGENTS.md support landed in Claude Code 2.1.277 and the mechanism underneath is the more interesting part. @shao__meng read the implementation and found four modes rather than a simple fallback — CLAUDE.md only, fall back to AGENTS.md, load both and deduplicate, or organisation-managed only — plus the gaps: @ mentions, IDE selections and notebook, image and PDF reads do not attach AGENTS.md, symlinks are not resolved, and it does not appear in /memory. It ships as one of four built-in mods, alongside a security default that protects managed hooks and tool policy from user-installed plugins, a /diff panel, and a telemetry hook, which is how @chunlea reads the whole thing: mods look like Claude Code being open-sourced piece by piece.
Agent marketplaces and multiplexers were the other cluster. AgentSky put 40-plus agents in a browser tab with cross-agent handoff that keeps context, and the recurring reason people give for wanting it is the same one: hitting a limit mid-task. Orca, Uncircle, Memoh, TasteCode, HarnessRouter and Orbital all arrived to solve some version of run several agents without drowning in terminal tabs.
Tencent's BrowserSkill was the most-tested new tool of the day, letting agents drive the Chrome you are already logged into via a local CLI and an extension, working with anything that can call a shell. Google's ARTEMIS did the same for Android over MCP. Cloudflare's agentic-inbox runs a self-hosted AI email client entirely on Workers with a Durable Object per mailbox and a hard human-confirmation step before anything sends.
Plugin4Shell is the security item to action: a zero-click remote code execution affecting Claude Code, Codex, Copilot and Gemini CLI, where the agent pins a marketplace plugin commit but never verifies the checkout actually hit that commit, so an auto-update can swap in malware while the pin still looks clean. Claude Code and Codex are patched; Copilot was still open and Gemini CLI is deprecated rather than fixed.
Memory keeps arriving from every direction: obsidian-second-brain updating existing pages and reconciling contradictions rather than appending, Memorable turning successful runs into reusable procedures, Distilly packaging a person's judgement as a skill, and several people wiring the same vault into Claude Code, OpenClaw and Hermes at once so every agent wakes up knowing the same things.
Jev from TypeSafe is the most-mentioned thing in the entire set by a wide margin, and the ecosystem around it appeared essentially overnight. @studio_yebisu catalogued the GitHub repos by genre in one morning and the spread is the story: browser and computer control, compaction, code review, model routing per turn, skill gating, search ranking, Postgres row filtering in natural language, ad blocking, sponsor-segment detection, prose linting, Home Assistant, Mario, drone avoidance, driving simulation. @BystAnd3rs ranked ten of them by immediate usefulness. The single most-installed is fast-jev-compaction as a Claude Code plugin.
AGENTS.md support landed in Claude Code 2.1.277 and the mechanism underneath is the more interesting part. @shao__meng read the implementation and found four modes rather than a simple fallback — CLAUDE.md only, fall back to AGENTS.md, load both and deduplicate, or organisation-managed only — plus the gaps: @ mentions, IDE selections and notebook, image and PDF reads do not attach AGENTS.md, symlinks are not resolved, and it does not appear in /memory. It ships as one of four built-in mods, alongside a security default that protects managed hooks and tool policy from user-installed plugins, a /diff panel, and a telemetry hook, which is how @chunlea reads the whole thing: mods look like Claude Code being open-sourced piece by piece.
Agent marketplaces and multiplexers were the other cluster. AgentSky put 40-plus agents in a browser tab with cross-agent handoff that keeps context, and the recurring reason people give for wanting it is the same one: hitting a limit mid-task. Orca, Uncircle, Memoh, TasteCode, HarnessRouter and Orbital all arrived to solve some version of run several agents without drowning in terminal tabs.
Tencent's BrowserSkill was the most-tested new tool of the day, letting agents drive the Chrome you are already logged into via a local CLI and an extension, working with anything that can call a shell. Google's ARTEMIS did the same for Android over MCP. Cloudflare's agentic-inbox runs a self-hosted AI email client entirely on Workers with a Durable Object per mailbox and a hard human-confirmation step before anything sends.
Plugin4Shell is the security item to action: a zero-click remote code execution affecting Claude Code, Codex, Copilot and Gemini CLI, where the agent pins a marketplace plugin commit but never verifies the checkout actually hit that commit, so an auto-update can swap in malware while the pin still looks clean. Claude Code and Codex are patched; Copilot was still open and Gemini CLI is deprecated rather than fixed.
Memory keeps arriving from every direction: obsidian-second-brain updating existing pages and reconciling contradictions rather than appending, Memorable turning successful runs into reusable procedures, Distilly packaging a person's judgement as a skill, and several people wiring the same vault into Claude Code, OpenClaw and Hermes at once so every agent wakes up knowing the same things.
Comments