Super User Daily: 2026-11-02
Saturday's best Claude Code stories were about plumbing, not prompts. One builder handed an agent the whole Linux desktop and then had to lock files with the immutable bit because the agent kept rewriting them; a game studio of one runs a night shift of single-job agents that can only remember through a handoff file. Several people finally read their own logs and found where the limits go: subagents waking up to a cold cache, long chats that never compact, wakeups that report nothing. The non-coding uses were small and real: a TV with no remote, a factory's job-number screen, a 62-year-old's account audit, a fridge board for kids. The other thread was trust. A server-side rule against recreating existing games arrived with no version bump, and people started treating their agent like a third-party API that can change overnight.
@NixFred [Claude Code]
https://x.com/NixFred/status/2116519626171461856
This builder lets an agent called Larry run the whole Omarchy and Hyprland desktop, and the write-up is a record of what broke. Copy and paste failed seven times in five days because tools kept rewriting or dropping config lines, so Larry built a clipboard-policy service: master copies live in git, a systemd path unit and a 15-minute timer put any drift back, and a test edit was reverted in two seconds. After three days of wrong monitor resolutions, monitors.lua now picks modes from the connector at load time and carries the immutable bit, with a timer that restored a deliberately broken mode in about six seconds. A SessionStart hook in Claude Code reports each session to herdr, which currently shows ten Claude panes in four states. The lesson is blunt: when the desktop is plain files an agent can edit, the important files need locks, not reminders.
@1DigitalC [Claude Code]
https://x.com/1DigitalC/status/2116530954030469235
This solo developer builds a survival game on a night shift: between 6pm and 9am on October 23 the agent lanes made 123 commits. Each lane is one Claude Code agent with one job, such as the world, the shelter, combat, characters, story or voices, and a runner feeds it one step per round. More than 5,800 agent sessions for the game are still on disk. The trick that makes it work is boring on purpose: every round starts with no memory, so every lane must write a handoff file before it stops and the next round must read it first. Reversed decisions go into one list of things the team stopped believing, because a stale instruction reads exactly like a decision someone already made.
@0xMovez [Claude Code]
https://x.com/0xMovez/status/2116538107017212194
This builder forked an open-source screen-sharing engine into DuoDesk, one mouse, keyboard and clipboard shared across a Windows PC and a MacBook, in two days without writing code by hand. Claude Code on Opus 5.5 read the whole codebase first, then 11 parallel agents rebranded about 370 files, with one agent assigned only to decide what must not be renamed so older devices still pair. GitHub Actions now builds the dmg, exe, AppImage, deb and apk on every tag, with the Mac build on Apple hardware in the cloud. Two moments are worth copying: when the cursor stuck at the screen edge, the agent added logging that says exactly why a crossing is refused, and when one agent took the live site down with a test deploy, it was rolled back in 20 seconds and every agent lost deploy rights.
@EmircanSahinX [Claude Code]
https://x.com/EmircanSahinX/status/2116522249456857462
This user's 200-dollar plan used to run out in 12 hours, and the cause turned out to be subagent caching. Subagents run on a 5-minute cache, and while the main agent tests, reviews and dispatches other work, more than five minutes often pass, so the next call to that subagent re-sends roughly 900K tokens uncached. With 20 or more subagents in rotation, that alone drained the plan. The fix is to track how long each subagent has been idle, through CLAUDE.md, a hook or a skill, and to spawn a fresh subagent with a summary instead of reviving an expired one. Ten subagents went from about 9M uncached input tokens to about 300K, and now even the 100-dollar plan lasts.
@roughneckactual [Claude Code]
https://x.com/roughneckactual/status/2116646833930060121
This user kept hitting Claude Code and Codex limits, so they read 30 days of their own logs instead of guessing. The total was 3.64 billion limit-weighted tokens, and about 26 percent of it was avoidable. More than half of the avoidable part, 51.3 percent, came from a single habit: long chats that never compact. They packaged the analysis as a local tool that runs with no network, so anyone can see their own split before changing anything. It is a small post, but it is the kind of measurement most limit complaints skip.
@0xMfox [Claude Code]
https://x.com/0xMfox/status/2116578686715457587
This user tied a widely shared compaction measurement to their own history. On a 400K-token Opus 5.5 session, /compact cost 0.17 dollars with a warm cache and 1.99 dollars after the cache expired, and the cache only lives up to an hour after the last message. Their own logs showed five compactions in three months, all warm, about two dollars in total, but the biggest one squeezed 970K tokens into 31K and the rest was simply forgotten. The resulting habits: compact before walking away rather than after coming back, use /clear for new work because it is free, tell /compact what to keep such as every error, path and number, and check whether the cache is warm in /usage.
@williamkast_ [Claude Code]
https://x.com/williamkast_/status/2116578950411636949
This marketing team fed Claude Code the scripts of every ad they tested over several months and asked it to compare winners and losers across all brands at once, instead of brand by brand. The findings were specific: concrete numbers beat claims, as in 45 grams rather than lightweight. One or two open questions carry a viewer from hook to call to action, but three or more confuse people and they scroll away. Swapping a new hook onto a winning ad mostly lost, so iterating a winner works better by repackaging the format than by changing words. The team now plans to run this cross-brand analysis regularly to train people.
@wakitahitecs [Claude Code]
https://x.com/wakitahitecs/status/2116346152316764622
This person is building their own production-management system for a manufacturing shop, on Supabase, Next.js and Vercel with Claude Code, and posted day 24 of the log. Floor users said the screens were sterile and text-heavy, so the look was rebuilt three times in one night, and the next day people still could not tell what screen they were on. The real cause was the entry point: the shop works by job number, which is written on every paper and drawing, while the app made people start from the type of work. The new design is one big search over the 519 live job numbers, with sorting such as due within 30 days or awaiting parts, refreshed every night from the existing core system. Adding features was easy; making a screen people can use was the real fight.
@codyplof [Claude Code]
https://x.com/codyplof/status/2116595343492030645
This former CEO of a cosmetics brand went from managing 100+ people to a team of two and now runs an entire marketing function through agents. A Grok Bot chief of staff runs all project management in Notion, and hands work to other agents including Claude Code, Codex and creative tools, which only works because every agent shares the same context layer. The author found even heavy AI users need reminders of what agents can do: ads were uploaded by hand for weeks before an agent turned out to do it easily. Their working style is long voice dictation with full context, multi-agent review and verification, and staying in the loop as little as possible. The post ends in a course pitch, but the operating detail is first-hand.
@web3_AIart [Claude Code]
https://x.com/web3_AIart/status/2116337276544536812
This 62-year-old user keeps a daily Claude Code practice log, and this entry started with a Microsoft sign-in alert from Italy, a country the author has never visited. Working through it with an AI assistant, the author changed the Microsoft password and turned on two-step verification, found Google and Apple already protected since 2020, and pruned forgotten connected apps from 35 to 27. The biggest find was on the iPhone: Stolen Device Protection was off, which would have let a thief who knew the passcode change the Apple password. The assistant explained each step and the author pressed the buttons, and the session ended on a very human note: turning on automatic updates failed because the phone was out of storage.
@bookiroad1 [Claude Code]
https://x.com/bookiroad1/status/2116327213343887675
This user could not find the TV remote one morning, so they asked Claude Code on a MacBook to list the devices on the home Wi-Fi instead of digging through the sofa. It found the LG U+ IPTV set-top box, installed the androidtvremote2 Python library and wrote the control code, and after the user typed the six-digit pairing code shown on the TV, it could report power state and the running app, change volume and switch channels. It hit a connection error and a bug with two-digit channel numbers along the way and fixed both. The author then built a small automation that turns the TV off at midnight, and the point stands: AI coding reaches the devices already in your house, not just websites.
@tianshi_li [Claude Code]
https://x.com/tianshi_li/status/2116565881153032411
This researcher built the slide deck for a talk at NVIDIA from a 174-line mental schema, using Quarto, Claude Code on Opus 5.5 at medium effort and a custom set of translation rules, and published all three. The appeal is the balance between delegation and direct control: the content stays exactly as written while the tedious layout work disappears. The author is candid about two caveats. The agent-written speaker notes were bad. And the goal of treating the schema as code with the agent as its compiler is only partly met, because the deck went through many rounds of editing the schema and asking the agent to update from the diff, so the final schema alone may not reproduce it.
@tvytlx [Claude Code]
https://x.com/tvytlx/status/2116596565443776788
This post breaks down a weekend build that put a Mario 64 level on a desk in mixed reality on a PICO headset, rendered natively in 3D at a steady 90 FPS. Claude Code on Opus 5.5 wired the n64decomp source, a byte-exact decompilation of the 1996 cartridge, into a Unity renderer, converted the N64 geometry, mapped controls to the MR controllers and chased down frame-pacing problems. The workflow is the part worth copying: with the Unity CLI and PICO CLI connected, compile, deploy to the headset and fix all ran in the terminal without a human pressing buttons. The author's rule of thumb for whether AI can do something in a weekend: the raw material must already be text, and the tools must be callable from the command line. The builder also owns a physical cartridge for the assets.
@mylifcc [Claude Code]
https://x.com/mylifcc/status/2116337358282887438
This thread relays an internal Spotify practice for cutting Claude Code costs, built around one observation: the expensive part is not deep thinking but mindless reading. Writing rules in CLAUDE.md did not work, because the model often ignored them. So the plugin, called shunt, uses a PreToolUse hook that blocks any attempt to Read or cat a file longer than 350 lines and forces a bulk-reader command, where a small model digests the file first. In a Java monorepo, read-related token use dropped by about 90 percent. The honest part is the list of what cannot be outsourced: a small model missed a subtle thread-safety bug that Claude caught in seconds, and summaries get line numbers wrong, so precise edits still need Claude to read the real lines.
@QuantumTransf [Claude Code]
https://x.com/QuantumTransf/status/2116463876594434496
This team built Obelisk, an open-source search system over coding-agent session history, and the design starts from a paper result. The paper found that simply keeping raw conversation history and retrieving it when needed won six of seven benchmark settings against elaborate agentic memory systems. Obelisk applies that to Claude Code, Codex, Hermes, Pi and OpenCode sessions, including tool calls, subagents and workflows, using SQLite FTS5 and agent-driven queries with no embeddings and no memory extraction. The questions it is built for are the ones summaries lose: why a piece of code was designed this way, how far the last agent got, which approaches were tried and why they failed. Memory, in their framing, should be a traceable history, not a summary that keeps getting rewritten.
@chenchengpro [Claude Code]
https://x.com/chenchengpro/status/2116338048728457411
This developer read how OpenCode now uses Claude subscriptions and posted the mechanics. It does not use OAuth; it goes through the official SDK so every model request is sent by Claude Code itself. At startup it hollows Claude Code out: tools set to an empty list so all built-in tools are off, settingSources empty so neither ~/.claude nor project settings load, and only mcp__opencode__ tools allowed, with OpenCode's own tools served as an in-process MCP server. Because the MCP handler cannot see the tool_use_id, it stores and retrieves it through a PreToolUse hook, which turns Claude's parallel file reads into serial ones, and Claude Code's built-in system prompt is the one that applies. The author's conclusion is that it is unlikely to beat using Claude Code directly.
@GoSailGlobal [Claude Code]
https://x.com/GoSailGlobal/status/2116355866173813230
This user gave the same two tasks, a one-sentence bookkeeping web page and a one-paragraph family ledger, to Claude Code bare and with 14 popular vibe-coding add-ons installed. Bare Claude Code finished both correctly in five minutes and passed all 12 checks. Three of the add-ons did not finish in time: GSD, prd-taskmaster and ai-prd-workflow. The other 11 also passed, but took 1.5 to 7.8 times as long and used 1.4 to 5.1 times the quota. If you must install one, the author ranks SuperClaude, a prompt template that never stops to ask, and rulebook-ai, which only adds rules and comes closest to bare, and publishes every screenshot and raw log.
@agentinternn [Claude Code]
https://x.com/agentinternn/status/2116451040123924701
This builder runs an agent that takes feature requests for a game from strangers and ships them to production, and the setup is a list of defenses. Every task is treated as untrusted input, screened by rules plus a separate model that has no tools. Claude Code runs in a sealed container with no secrets, and the game lives on its own origin inside a sandboxed frame. A test gate decides what ships, and a person starts every shift and approves each step. The author says prompt injection is the hard part and wrote up how each layer is built.
@TanZeng1021 [Claude Code]
https://x.com/TanZeng1021/status/2116339397872517288
This founder's website was vibe-coded and users said it read too technical, so a designer, a product person and the founder redesigned it together on tutti. All three shared one Claude Code subscription running in the cloud, which never ran out of quota for a three-person website job, and long tasks no longer kept anyone's laptop awake. Environments, context and assets sync live, like a shared document: each person can see what the designer is changing and their conversation, and pick up that session to keep editing. Because everyone sits in the same environment, finished pages and long jobs like video generation can be previewed by anyone in real time, and the author says the human-to-human handoff steps simply disappeared.
@marketcallsHQ [Claude Code]
https://x.com/marketcallsHQ/status/2116595037505216933
This open-source trading platform team says about 96 percent of its development now runs as an AI software factory built on a mix of Claude Code and Codex. Agents write code, review pull requests and handle merges, while humans own product decisions, specifications and testing builds against live brokers. Measured against Dan Shapiro's levels of AI coding, they put themselves at level 4, where people write specs and check tests, moving toward level 5, where no human writes or reviews code. The activity numbers back it up: from an average of 25 contributions a week in 2024 to 312 a week in 2026, and more than 17,500 since January 2024.
@zawa_c_i [Claude Code]
https://x.com/zawa_c_i/status/2116323021044805825
This user backs up Claude Code and Codex data, conversation records and settings, with Google Drive for desktop on a Mac and wrote down every snag. Parent and child folders cannot both be synced (a NESTED_ROOTS error), and adding a big folder first creates an equal-sized temporary copy that briefly cut free disk space to 400 MB. Keys stay out of sync entirely: logins live in the macOS Keychain, and the author checks that Claude Code has not fallen back to a credentials file under ~/.claude, and found old key values sitting in conversation transcripts, which got rotated. Codex kept a roughly 7 GB SQLite database that rewrote every two to three minutes, so it was moved out with sqlite_home, while Claude Code's transcripts synced fine as plain files. And sync copies deletions too, so upload-then-delete is not a backup.
@daniel833648786 [Claude Code]
https://x.com/daniel833648786/status/2116345697582854542
This user hit 90 percent of a top-tier Grok quota with three days left, even though their bots were already told to delegate execution to Claude Code and Codex, so they had a bot audit every bot's usage. It found 594 wakeups in a week, about half of them pointless, so bots now wake only for a result, an error or a decision. One pull request, from code through tests, Codex review and click-through screenshots, now runs as a single script with one wakeup. Each PR gets a fresh executor instead of one long-running context, progress reports are short, and a monitor checking iPhone restocks every two hours was deleted. The author plans to review the effect on November 3.
@KOF97AI [Claude Code]
https://x.com/KOF97AI/status/2116347545429696808
This developer runs Claude Code and Codex together through a written handoff sheet instead of labeling one tool as the architect and the other as the coder. The planner only reads the relevant code and delivers the goal, interface changes, migration risks and acceptance criteria, and anything it did not read is written down as unknown rather than guessed. The implementer trusts only that task file in the repo, never a pasted chat, and two sessions never edit the same files at once; parallel work goes into separate branches or worktrees. The reviewer gets the requirements, the diff and the verification output and hunts for counterexamples such as privilege bypasses and regressions, and even its approval does not count until the checks actually run.
@ganz [Claude Code]
https://x.com/ganz/status/2116640518373327094
This parent built a bespoke education app for their kid that is mostly voice discussions and debates with Opus about the books the kid reads. At any point the kid can just say out loud that something is broken or ask for a change, and a Claude Code instance behind the scenes implements it right away. The author describes the strange experience of watching a child mold their own software while using it. It is a tiny deployment, but it shows the self-editing app pattern working for a user who will never open a code editor.
@EtienneServant [Claude Code]
https://x.com/EtienneServant/status/2116667713951055966
This app maker keeps several Claude Code sessions open on their phone, at least one per app they run. Whenever an idea or a piece of feedback comes up, they send a voice note to the right session and let it merge straight to production. A few months ago the same person kept a carefully groomed Linear board and built and reviewed tasks one by one; now the whole process is a voice note and send. It is the riskiest workflow in this edition, and the author calls it yolo, but it shows how far the review step has collapsed for personal software.
@tonychang430 [Claude Code]
https://x.com/tonychang430/status/2116582989932970336
This developer's coding setup is a three-layer chain: a Grok Bot orchestrator, Claude Code sessions in the cloud doing the engineering, and a QA bot. Grok Bot holds the author's memories, spawns the cloud Claude Code sessions and summarizes what the workers report, so the author does not have to read every agent-to-agent conversation. The Claude Code sessions have remote control and computer use, so progress can be checked from a phone. For bigger tasks the author still steps in: if a session is stuck or heading the wrong way, they open it, read the conversation and talk to Claude Code directly instead of relaying through the orchestrator.
@eliron_giny [Claude Code]
https://x.com/eliron_giny/status/2116584339915837765
This builder picked up a former Claude Code team member's warning about agent mania, the feeling of working nonstop while nothing actually ships, and paired it with METR's controlled study where experienced developers expected to be 24 percent faster with AI, believed afterward they were 20 percent faster, and were actually 19 percent slower. The author's working rules are concrete. One task stays open until it is live; done is defined before starting, which means tests pass, it deploys and a real user has seen it. At most three parallel sessions, and only on tasks that do not depend on each other. At the end of the day count what shipped, not what was started, and when the urge comes to open another agent instead of closing the current one, stop and ask what you are avoiding.
@naoki_ninja_ [Claude Code]
https://x.com/naoki_ninja_/status/2116357090667016246
This user shares a pre-launch check to paste into Claude Code before publishing an app the AI built. It asks the agent to act as an attacker logged in as an ordinary user and look for five things: secrets left in files or git history, entry points that skip login checks, other users' data reachable by changing an ID in the URL, paid AI endpoints that can be called without limit in a short time, and sensitive data left in front-end code or server logs. It must list each problem with file, line and fix, and the last line tells it not to change any code yet. On a practice app seeded with all five problem types, it found all five in 48 seconds, listed eight findings, and left every file untouched.
@byamadaro1013 [Claude Code]
https://x.com/byamadaro1013/status/2116350499113058602
This user did a full marketing push in one day with Claude Code and Cowork: picked a target segment and listed 10,000 companies, packaged a product for a specific industry, wrote 50 SEO articles and a press release, and set up Google search ads despite being a beginner at it. The author estimates a marketing agency would have charged about 2 million yen over three months for the same scope. It is a short post without the artifacts attached, but the scope is the point: a one-person, one-day pass over work that used to be a quarter-long contract.
@xingkaixin [Claude Code]
https://x.com/xingkaixin/status/2116333737856410017
This developer accepts that sessions are split by vendor: OpenAI models in Codex, Claude in Claude Code, others in pi, some in a desktop chat app. Merging them would not help much, they argue, because the hidden thinking from OpenAI and Claude does not carry over well anyway. For cross-agent work they use only pi: both Codex and Claude Code have a skill that calls pi -p to hand off jobs better suited to another model, and when a real handoff is needed they just send the path of the session's jsonl file. They do not chase a fully automatic software factory and rarely work from a phone; the one itch left is coordinating across several machines.
@ReignSwords [Claude Code]
https://x.com/ReignSwords/status/2116353653313327444
This user tried the widely shared five-step recipe for letting Grok Bot install and log into Claude Code and Codex on its own cloud computer, so that writing goes to Claude, code goes to Codex and browser work stays with the bot. The setup works with existing subscriptions and no API keys, but the author lists three real traps. The cloud computer belongs to the account, not to a bot, so every bot under that account can reach the Claude token you put there. The claude setup-token command produces a one-year token whose auth file is as good as a password. And each service bills separately, so the saving is in switching windows, not money; the most valuable part is the division of labor written into every bot's system prompt.
@railsonmaui [Claude Code]
https://x.com/railsonmaui/status/2116320318155559094
This developer argues that since nobody can read all the code agents write, fast merge decisions depend on a pull request description that carries evidence. They asked Claude Code to simplify a skill's home page, which went from ten sections to five, and the PR that came back states why the change exists, shows before and after screenshots, and ends with a checkpoint saying what happens next. The author singles out that it reads without the usual AI filler. It comes from their open-source Shaka skill, which an agent installs and checks with a doctor command.
@zoe_on_x [Claude Code]
https://x.com/zoe_on_x/status/2116356224656834944
This parent turned the family fridge dry-erase board into a small web app built with Claude Code to keep the kids on track after school, covering homework, activities and chores. It is now the home page on the kids' browsers, so the plan is the first thing they see. The author notes it works for homeschooling too and released it free and open source with a live demo. A reply in the same thread put it well: a board the kids actually look at beats any fancy app.
@wshuyi [Claude Code]
https://x.com/wshuyi/status/2116328521195032701
This creator posted an operation demo video recorded inside WorkBuddy and pointed out that Claude Code did all of it. It planned the steps, operated the software, recorded the screen, edited the footage and added the voiceover. The author says this makes walkthrough-style videos far easier to produce from now on. A separate reply in the same feed noted the music in a similar video came from a CLI that calls a local music model, which suggests the whole pipeline can stay inside the terminal.
@gh_TechLuddite [Claude Code]
https://x.com/gh_TechLuddite/status/2116579399952912605
This open-source maintainer says that wrangling security and maintenance for everything they have published had become too much, so they spent a homelab night with Claude Code simplifying it. In one session they retired two services, moved private CI to Gitea Actions, added an AI review on every pull request, put a gateway in front of their MCP servers and self-hosted T3 Code. It is a maintenance story rather than a build story, which is exactly why it is useful: the agent is being used to reduce surface area, not add to it.
@l1s_ai [Claude Code]
https://x.com/l1s_ai/status/2116585909806313484
This user found exploit attempts in their Synology NAS logs during a recent ransomware wave and responded by building and open-sourcing synology-nas-cli. It is a Python CLI plus an MCP server for DSM management, security audits, one-click configuration fixes and alerts within ten minutes. Because it speaks MCP, Claude Code, Codex and Cursor can run the audit and apply fixes directly. It is a good example of the defensive side of agent tooling: a home admin turning a scare into a reusable audit.
@RoundtableSpace [Claude Code]
https://x.com/RoundtableSpace/status/2116481557397385258
This post covers Video to Game, a skill for Claude Code, Codex, Cursor and Gemini that turned 31 short AI videos into 31 playable browser games for about 6 dollars each. A video model designs the look, the camera and one mechanic; the agent studies the clip frame by frame, generates every image, 3D model and sound to match, and writes the game in Three.js as a single HTML file. Then it plays its own game and fixes falls through the floor, walls and dead moments. All 31 games and the skill are public, which makes the claim checkable.
@dani_avila7 [Claude Code]
https://x.com/dani_avila7/status/2116352019564777669
This builder made Rex Claude, a Claude Code skill that lets Claude control panes and tabs in the Rex terminal. After experimenting with Rex for a while, they built it so Claude can open new panes, launch independent Claude Code sessions in them and coordinate work between them. The sessions can exchange instructions, monitor each other's progress and detect when another session finishes or needs attention, all orchestrated from one Claude Code session. Replies show the demand: people running three or four sessions at once say they lose track of which pane is doing what.
@themuscleai [Claude Code]
https://x.com/themuscleai/status/2116577799880208571
This user installed a memory plugin with more than 100,000 stars inside a sandbox before trusting it, and documented what the star count did not say. The README's quick start leads into a browser sign-in with an email magic link, a provisioned memory key and a 30-day trial of the hosted observer, after which memory falls back to the user's Anthropic plan unless they subscribe. Local mode ended the install with a fatal error about a missing observer, and the author concluded that the provider choice is the real install decision and is made before any session runs. The README does document an opt-out, which the author credits, but the takeaway is general: stars measure attention, while the provider line tells you where your session data goes.
@itwanger [Claude Code]
https://x.com/itwanger/status/2116353833035346062
This user isolates part of Claude Code's work in a virtual machine to save tokens on a Pro plan. Inside the VM runs Pi Agent with a DeepSeek API key, and since DeepSeek provides search and fetch, any job that needs reading web pages is handed to Pi instead of letting Claude Code read the pages itself. Pi returns only the result to Claude Code. If a fetch fails, Pi falls back to opening the page in Firefox inside the VM.
@DanKornas [Claude Code]
https://x.com/DanKornas/status/2116646648952783046
This post covers Kanzo, a local kanban board and MCP server in one program for people working with coding agents. You and your agents share the same board: Claude Code, Codex or any MCP client sees the tasks you see in the browser, moves cards to doing and leaves comments as it works. Data stays in a local SQLite file with a TOML settings file and no account, and boards sync between machines through a private git repo. The detail worth noting is an agent-safe backlog column where ideas sit untouched until a human moves them to todo, which answers the common complaint that agents grab work nobody approved.
@0xKentaBG [Claude Code]
https://x.com/0xKentaBG/status/2116320468819181877
This builder's starting point is that Claude grading its own code amounts to Claude approving its own code. So they built an /audit command: a separate auditor with zero chat history that checks each build step against the user's plan. It runs the free checks first, only looks at new code and works within hard limits, which keeps it cheap. The author calls it blunt on purpose, and it is the same idea the big security agents converged on this week: the agent that wrote something should not be the one that signs off on it.
@kellerai_kai [Claude Code]
https://x.com/kellerai_kai/status/2116352616045170923
This post introduces Freshlint, a free open-source Claude Code plugin aimed at a quiet failure: coding agents keep acting on memory notes long after the code those notes describe has moved. Freshlint ties each note to the code it cites and flags it at session start when that code has changed or is gone. The same complaint showed up elsewhere in the day's posts, from a user whose markdown wiki kept citing stale notes as current because nothing ever pruned it.
@vintesetFM [Claude Code]
https://x.com/vintesetFM/status/2116350004512374925
This creator maintains a Football Manager data project and compared two seasons. Building the dataset for FM26 took about 30 days of work. For FM27 the data structure changed, and adapting it with Claude Code took about two hours, done live on stream. It is a short reply, but it is a clean before-and-after on the same task by the same person.
@BentoBoiNFT [OpenClaw]
https://x.com/BentoBoiNFT/status/2116323418639393248
This user tested several personal agents, including OpenClaw and Hermes, and says the setups took a whole day each, while Grok Bot worked out of the box with surprisingly good output. They now have Grok Bot controlling both their Claude Code and their Hermes agent. It is one of the few first-hand OpenClaw mentions in the day's data, and it is a departure story rather than a usage story, which matches the wider mood: long-time OpenClaw users describe it as the thing that set the direction, while the daily driving has moved to hosted orchestrators.
@AsWill11 [Claude Code]
https://x.com/AsWill11/status/2116345411686502867
This post relays how one builder shipped a free disk cleaner for macOS and Windows in an afternoon with Claude Code on Opus 5.5, described as a behavioral rebuild rather than a cracked copy of paid tools. Opus drew nine UI concepts before polishing one, and eight parallel agents split the scanner, disk map, assistant and installers across one Electron and React codebase. The load-bearing step was a separate safety agent that attacked every delete path, and it caught a Windows short-name wipe risk (paths like DOCUME~1) and an icon loader that could leak a password hash. The builder says the first real click freed 14.6 GB; the relayer is clear they have not rebuilt it.
🗣 User Voice
User Voice
Server-side rules are now treated as a supply-chain risk. @koltregaskes reports Claude Code refusing to recreate existing games even when renamed; @ryan_ntk points out the rule arrived through a remote config field with no version change, so the same version and the same prompt no longer guarantee the same behavior, and suggests daily evals that alert on refusals; @jimmyyangrz sums up the complaint as rules changed on the server that users cannot see until they hit them.
Cache literacy is the new cost skill. @elvisautet says the priciest moment in a session is coming back from a break to a cold cache; @techfren flags background agents re-sending a whole chat every 30 seconds just to write a status label; @AdamHoltererer notes that about half of the Opus 5.5 tokens on OpenRouter run through Claude Code at API rates; @Akki_AI7 burned about 1.1M tokens on one article because seven subagents overlapped.
Running two agents on one repo still loses context. @shakhzod1001 and @leoleotoobad both ask how people keep Codex and Claude Code in sync when each switch erases what the other did; @MihirKolakaluri's answer is to never switch and have Claude Code call Codex inside the same session; @KnightLogics ranks two agents on one repo last because syncing them ate the time saved.
The working directory is a trust boundary. @bludr5 never launches from ~/Downloads because the agent reads stray CLAUDE.md or AGENTS.md files before the prompt; @dansyu_callenge warns that a written rule to confirm before deleting did not stop an agent from wiping a home folder, so deletes belong in settings deny rules; @pinesun11 now opens unknown repos in a VM after a patched preview bug.
Mobile and multi-session control is still rough. @alliekmiller calls the remote function weak and uses Codex on the phone; @Tony_Stef_ runs 50 to 100 sessions and never launches half the child sessions Claude Code suggests; @JoshisElsewhere wants the coding agent and the personal assistant to keep separate contexts. On the OpenClaw side, @kevinma_dev_zh and @avaaum describe Grok Bot as the hosted version of what OpenClaw set out to be, and @davelee jokes that OpenClaw was all the rage ages ago.
Server-side rules are now treated as a supply-chain risk. @koltregaskes reports Claude Code refusing to recreate existing games even when renamed; @ryan_ntk points out the rule arrived through a remote config field with no version change, so the same version and the same prompt no longer guarantee the same behavior, and suggests daily evals that alert on refusals; @jimmyyangrz sums up the complaint as rules changed on the server that users cannot see until they hit them.
Cache literacy is the new cost skill. @elvisautet says the priciest moment in a session is coming back from a break to a cold cache; @techfren flags background agents re-sending a whole chat every 30 seconds just to write a status label; @AdamHoltererer notes that about half of the Opus 5.5 tokens on OpenRouter run through Claude Code at API rates; @Akki_AI7 burned about 1.1M tokens on one article because seven subagents overlapped.
Running two agents on one repo still loses context. @shakhzod1001 and @leoleotoobad both ask how people keep Codex and Claude Code in sync when each switch erases what the other did; @MihirKolakaluri's answer is to never switch and have Claude Code call Codex inside the same session; @KnightLogics ranks two agents on one repo last because syncing them ate the time saved.
The working directory is a trust boundary. @bludr5 never launches from ~/Downloads because the agent reads stray CLAUDE.md or AGENTS.md files before the prompt; @dansyu_callenge warns that a written rule to confirm before deleting did not stop an agent from wiping a home folder, so deletes belong in settings deny rules; @pinesun11 now opens unknown repos in a VM after a patched preview bug.
Mobile and multi-session control is still rough. @alliekmiller calls the remote function weak and uses Codex on the phone; @Tony_Stef_ runs 50 to 100 sessions and never launches half the child sessions Claude Code suggests; @JoshisElsewhere wants the coding agent and the personal assistant to keep separate contexts. On the OpenClaw side, @kevinma_dev_zh and @avaaum describe Grok Bot as the hosted version of what OpenClaw set out to be, and @davelee jokes that OpenClaw was all the rage ages ago.
📡 Eco Products Radar
Eco Products Radar
Codex (146 mentions): the default second agent, used for review, long tasks and phone work alongside Claude Code.
Cursor (105): mostly the tampered extension incident in its marketplace, plus side-by-side diff reading.
Gemini (38) and DeepSeek (34): cheaper models routed into Claude Code through gateways, and DeepSeek Harness as a comparison point.
OpenCode (34): now uses Claude subscriptions through the Agent SDK; users debate the 1.7x faster five-hour drain.
Grok Bot (33): the orchestrator many users put above Claude Code and Codex.
Hermes (19) and Muse (14): personal agents that users compare against Grok Bot and OpenClaw.
Aura Autopilot (12): open-source game playtesting agent benchmarked against Claude Code.
Blender MCP and Blender skills (12): 3D and animation pipelines driven from Claude Code.
Magpie (9): local gateway that swaps models and shares subscriptions across agents.
claude-mem (8): cross-session memory plugin, with users checking where its data goes.
TokenEconomizer (6): Microsoft Research and Berkeley plugin that learns from past sessions to cut cost.
T3 Code (5): remote control surface for agents running on your own machines.
Codex (146 mentions): the default second agent, used for review, long tasks and phone work alongside Claude Code.
Cursor (105): mostly the tampered extension incident in its marketplace, plus side-by-side diff reading.
Gemini (38) and DeepSeek (34): cheaper models routed into Claude Code through gateways, and DeepSeek Harness as a comparison point.
OpenCode (34): now uses Claude subscriptions through the Agent SDK; users debate the 1.7x faster five-hour drain.
Grok Bot (33): the orchestrator many users put above Claude Code and Codex.
Hermes (19) and Muse (14): personal agents that users compare against Grok Bot and OpenClaw.
Aura Autopilot (12): open-source game playtesting agent benchmarked against Claude Code.
Blender MCP and Blender skills (12): 3D and animation pipelines driven from Claude Code.
Magpie (9): local gateway that swaps models and shares subscriptions across agents.
claude-mem (8): cross-session memory plugin, with users checking where its data goes.
TokenEconomizer (6): Microsoft Research and Berkeley plugin that learns from past sessions to cut cost.
T3 Code (5): remote control surface for agents running on your own machines.
Comments