Super User Daily: 2026-11-14
Claude Code had a strange new day job on November 12: render farm. The best posts were films, anime fights, Houdini frost and a ramen stall in the rain, and none of them used a video model. The model writes Python, three.js or React, and Blender, Cycles or the browser draws the pixels, so a four-minute video now renders on a GTX 1050 Ti. The second thread was cost literacy with real receipts: a 42-agent run that halved in price once subagents stopped inheriting Fable, a week of logs showing the prompt cache falls off a cliff at exactly one hour, and a 35-run test where a team of subagents cost 38% more than one agent with skills for the same score. The third was coordination: branches for shared agent data, recovery paths for crashed workers, and one developer whose sessions were quietly contradicting each other. And the quiet wins were tiny personal tools, a family calendar on an old iPad, a locked-down PC for a kid, a fan-merch order tracker.
@Jocker_zero [Claude Code]
https://x.com/Jocker_zero/status/2120718799112700027
A short film with no video model anywhere in the pipeline. Fable 5.2 wrote Python inside Claude Code to drive Blender, Cycles rendered the library, the volumetric moonlight, the depth of field and all 1,236 frames, and the 24,000 flying pages run on a custom NumPy simulation instead of Blender's particle system. Even the score and the paper sounds were generated in Python before ffmpeg assembled and graded the cut. The working order is the part worth copying: lock the look with concept art, block seven shots at low resolution, and only spend the expensive render passes once timing and transitions are settled.
@DDJCXX [Claude Code]
https://x.com/DDJCXX/status/2120698092307763654
A 78-second anime fight scene drawn entirely by code, with no AI image or AI video in it. The creator ran one director conversation plus six groups in Claude Code (city, sky, villain, hero, effects, sound) working in parallel, all bound by one production contract where each group only edits its own files. The contract hard-codes rules like feet must not slide on landing and bodies must not clip, and a script checks every frame and refuses to render if a rule fails. The result is 31 shots and 1,877 frames computed by three.js in the browser on Opus 5.5, and the reusable lesson is to write the shot list and the physical rules as checks a machine can run.
@Vladic_ETH [Claude Code]
https://x.com/Vladic_ETH/status/2120823408870985780
A four-minute, 7,200-frame video rendered on an i5-13400F and an old GTX 1050 Ti, where every frame is a React function of time. The method is a seven-part brief (role, context, real material, style, timed scenes, hard rules, output spec) instead of make-it-cool prompts, plus contact sheets cut from reference videos at two frames per second so the vocabulary of a style can be named and pasted into the prompt. The style itself lives in a skill folder with instructions, a template and render tools, so after the first build a new video costs one prompt. The creator runs two such skills, one for topic-to-mp4 explainers and one for documentaries built from real data and licensed photos.
@BeyondTheBoxCN [Claude Code]
https://x.com/BeyondTheBoxCN/status/2120675443041034369
A playable 3D adventure prototype in Unreal Engine 5, built in about four hours from one chat window, as relayed from the developer neviannn. Opus 5.5 first proposed five game ideas and was told the GPU spec so it could cap graphical complexity, then Claude Code coordinated Meshy for models, Blender for asset cleanup and UE5 for levels, lighting, physics and HUD, all through MCP. The full initial build used 19% of a Claude Max weekly quota. The point for indie developers is that characters, materials and systems from level one carry straight into the next level, so testing several game ideas cheaply becomes realistic.
@dayiakadijital [Claude Code]
https://x.com/dayiakadijital/status/2120793016398971197
A free local image and video setup where the user did not even do the install. They told Claude Code to install ComfyUI and Wan 2.2 and to pick the GGUF build that fits their graphics card, and it downloaded, installed and configured everything. Wan 2.2 is open source and runs locally, one model for both images and video, with no subscription, credits or limits. The suggested next step is adding a free TTS and testing a faceless channel at zero cost, with the honest caveat that it is slow but free.
@colerepo [Claude Code]
https://x.com/colerepo/status/2120698516305572227
Same prompt, same Blender, same machine, three models: a ramen stall in the rain with a moped riding past, all procedural Python with no assets. Gemini 4 Carbon in Cursor cost $2.78 and made the cleanest, most readable stall but barely any street, over about four hours that were mostly provider errors. Fable 5.2 in Claude Code cost about $18.60 in 39 minutes and nailed mirror puddles and neon bokeh while the stall itself went dark, and Opus 5.5 cost about $7.54 in 27 minutes with a wooden cart, real steam and weak reflections. The most expensive run was not the best stall, which is a useful corrective to the pick-the-top-model reflex.
@uzu_ars [Claude Code]
https://x.com/uzu_ars/status/2120857799634919898
A Houdini artist had Claude Code write VEX to grow frost on ice, inspired by another artist's work. Stretching noise of the same strength and scale along the flow made the outline detail about 1.9 times finer, measured across three seeds at 1.89 to 1.98. The first comparison was wrong because the strength had changed too, so it was redone with only the stretch varied. The branching still looks fake, and saying so is what makes this a real experiment log rather than a demo reel.
@SergeForge [Claude Code]
https://x.com/SergeForge/status/2120876179133538745
A direct test of Anthropic's claim that one agent with skills beats a team of subagents: two real builds, 35 runs, Sonnet 5.5 for every agent. Quality was the same both ways, every site passed all 40 hidden tests on the harder build and blind design scores tied. The team cost 38% more and took twice as long, $1.31 and 29 minutes versus $0.81 and 15 minutes per site. The two team failures came from a handoff: the tester called a warning a false alarm, the orchestrator shipped the fix anyway, and keyboard booking broke.
@plusxbt [Claude Code]
https://x.com/plusxbt/status/2120866558117367980
A real 42-agent run priced twice on the same tokens: $32.84 with subagents on Fable 5.2, $16.97 with them on Opus 5.5. The trap is that switching the main session to Fable quietly puts Plan and general-purpose subagents on Fable too, and only Explore drops to Opus on a subscription, which /tasks shows mid-run. The fix is two env settings, CLAUDE_CODE_SUBAGENT_MODEL set to opus and CLAUDE_CODE_SUBAGENT_MODEL_FORCE set to 1, then launching with --model fable so only the main chat stays on the expensive model. Forks and skills set to model: inherit still follow the parent, so check /usage for the subagent share afterwards.
@harrisonju [Claude Code]
https://x.com/harrisonju/status/2120735775885070400
A week of personal Claude Code logs pulled apart to find where prompt-cache misses come from. 98.4% of input tokens were cache reads, and 96% of the 3,049 missed requests were one of three events: the first request of a session, the first after compaction, or the first after more than an hour idle. The hour is a cliff, not a slope: idle 55 to 60 minutes missed 1.6% of the time, idle 65 minutes to two hours missed 99%. Since every write was a one-hour write, a miss rewrites the whole context at twice base input price instead of reading it at a tenth or less.
@kaushik_holla [Claude Code]
https://x.com/kaushik_holla/status/2120672925627940936
A cost experiment that started from asking Claude itself whether a tip was true. Claude Code waits until the conversation nears the context limit before compacting, so on a 1M model each turn can resend close to a million tokens; setting /autocompact 400k makes it summarize earlier and every turn carries far less. The setup is three steps: run /autocompact to see the current window, run /autocompact 400k, or add autoCompactWindow 400000 to settings for every model. The stated catch is more frequent compaction and some lost detail, and the user is running it on one long session this week to measure the actual drop rather than trusting the theory.
@tvytlx [Claude Code]
https://x.com/tvytlx/status/2120898411776065623
A sharp read of a new eight-engine search plugin for coding agents, built from its own published numbers. Across 485 real developer questions, merging eight search APIs lifted top-10 hit rate only from 58% to 62%, while asking the same question three different ways lifted every engine by 12 to 16 points. The README also shows that by default the plugin sends search queries and the model's pre-search reasoning back to its servers, with an option to send far more. The practical takeaways are to add one line to AGENTS.md forcing three rephrased searches when the first fails, and to set the trace-off variable before using it on company code.
@eriks_b [Claude Code]
https://x.com/eriks_b/status/2120829716743819322
Round two of a Copilot CLI versus Claude Code rematch on a bigger, messier TypeScript backend, with tasks modelled on bugs the author really had to fix. The main task baited agents into patching every place that saves a record when the real fix was a few lines in one stream handler. The first results looked bad for both until the author read the patches and found the grader was broken: it counted docs as code and rejected a good fix because the handler had a different name. After fixing the grader it was a draw, and the next round will replay the actual bug from a real repo, which is exactly the right lesson about evals.
@_avichawla [Claude Code]
https://x.com/_avichawla/status/2121008480291295394
A concrete test of the problem every multi-agent team hits: two agents writing to the same data without silently undoing each other. Codex and Claude Code got one shared graph of services and teams, one task each: Codex moved a service from RabbitMQ to Kafka, Claude Code reassigned that service's on-call. Both started from the same version, Codex merged cleanly, and Claude Code was flagged for a conflict, rebuilt its change on the latest main and then merged. The argument is that row locks only help at the same instant, while an agent task touches many records over minutes, so branches, diffs and merge checks fit agent writes better.
@yeemio [Claude Code]
https://x.com/yeemio/status/2120709039806197812
A small orchestration tool iterated in public after commenters pointed out that coordinating files is not enough if a crashed worker leaves the task stuck. Version 0.25.4 adds an explicit recovery path: register a task with an owner, a named successor and the files to preserve, and have the worker save checkpoints as it runs. When the successor asks to take over, the tool first wakes the original worker and only accepts a changed checkpoint as proof of progress, not a bare acknowledgement. If there is no confirmed progress, the successor resumes from the last checkpoint in an isolated workspace that the old attempt can no longer write to, and a timeout is logged as unconfirmed rather than as a crash.
@kocienda [Claude Code]
https://x.com/kocienda/status/2120899843539558786
A developer asked their own tool, Tug, what it would take to add Codex CLI as a second session engine, and published the resulting design brief. The central finding is that Tug depends on Claude Code as a harness, not as a model: the tool loop, permissions, hooks, plugins and skills, transcript storage, resume, fork, rewind, compaction and subscription login all come from it. Very little of the work is the wire protocol; most of it is replacing, borrowing or gating those services. The brief also labels its own evidence, noting which claims came from read-only code sweeps and which came from third-party write-ups that still need checking.
@AntonMartyniuk [Claude Code]
https://x.com/AntonMartyniuk/status/2120780383952466326
A .NET developer collapsed a three-tool workflow (Cursor for AI, Rider for debugging, GitHub for review) into one window with Rider 2026.3 and its bundled Air agent workspace. Air finds the agents already installed, including Claude Code and Codex, uses the subscriptions already paid for, shows which sessions are running, done or waiting, and lets you comment on a diff line and send it back. Last week Claude Code refactored a service in one project while Codex wrote integration tests in another, and both showed up in the same place. The reason to leave Cursor was mundane and convincing: C# navigation and renames in large solutions, plus a real debugger.
@akshay_pachaar [Claude Code]
https://x.com/akshay_pachaar/status/2120929349151142257
A demo of an open-source, self-hostable layer that puts Claude Code, Codex and Hermes on one team with a shared whiteboard. Nine weeks of sample product data went into PostHog, and the question was why new users were not coming back. Hermes found where they dropped off in PostHog, Claude Code found why in the user feedback, and Codex built the dashboard, with a super agent deciding which agents the job needed and asking permission before creating them. It runs on existing subscriptions or API keys and shows every handoff, which is the piece most multi-agent setups hide.
@orcdev [Claude Code]
https://x.com/orcdev/status/2120983587289805070
A heavy user explains why their daily driver is T3 Code wrapped around Claude Code and Codex rather than either one alone. All the accounts, Claude, Codex and Cursor, live in one app, the mobile app works, and both machines are connected so sessions move to whichever has memory to spare. MCP and CLI access let a Grok Bot orchestrate T3 Code sessions, and the open-source codebase means bugs can be raised with a real person. The line that sums it up is not having to worry that agents will just stop in the middle of the night.
@sam_commonly [Claude Code]
https://x.com/sam_commonly/status/2120694967899451498
A small but very real failure mode of running many Claude Code sessions: arguing with yourself. One session is told to delete an old API while another is told to add tests for that same API, and both work very diligently. The fix being designed is a daily diary that reads every session, pulls out the contradictions and lets the user click which instruction wins. Each requirement shows up as a little jellyfish that gets a star when it is done, which is a cute way to say the missing layer is cross-session intent, not more agents.
@realjaymes [Claude Code]
https://x.com/realjaymes/status/2120880481684029519
A portability setup built on the assumption that a new model or agent will ship every week. Rules live in one file, workflows are skills, memory sits in Obsidian notes and connections are plain scripts, all owned by the user. Claude Code does most of the work, and Codex reads the same rules through a short adapter and picks the job up when a usage limit hits. If a better agent appears, it gets pointed at the same files, so switching costs almost nothing.
@chainnotsaw_man [Claude Code]
https://x.com/chainnotsaw_man/status/2120876372390547787
A practical workaround for features that span several repos. The user starts a Claude Code session in the base repo, pulls the others in with /add-dir, and keeps a dedicated GitHub wiki for specs and planning docs. It works and is part of the daily workflow, but the stated limitation is that local skills and guidelines do not travel across devices, environments and cloud sessions. What they want is one central, consistent way to manage agent context, skills and tooling across many repositories.
@lancinimarco [Claude Code]
https://x.com/lancinimarco/status/2120865465035805051
A developer's updated AI workflow, written up as a blog post. Claude Code moved off the laptop onto a Hetzner VPS sitting behind Cloudflare Zero Trust. Parallel sessions run in isolated git worktrees, and sub-agents split the work between threat modelling and implementation. It is a compact template for anyone who wants always-on sessions without exposing a box to the internet.
@itsmikica [Claude Code]
https://x.com/itsmikica/status/2120738456158564591
A server tool that grew a feature out of a plain admission: Claude Code on Fable 5.2 is good at changing things on servers, and it is not never wrong. The new feature backs up the whole server before a risky change. When something breaks, it restores only the part that broke instead of rolling the entire machine back. It is the server-side version of the undo button people keep asking for.
@jeff_barker_rei [Claude Code]
https://x.com/jeff_barker_rei/status/2120674411468542355
A family calendar for an old iPad Air, built because the free DAKboard plan was limited and buggy. Claude Code was told the device was an older iPad and worked out the browser and feature limits on its own, all inside a zero-dollar budget beyond the Claude subscription. Fable 5.2 wrote the full build spec, Opus 5.5 built it, and it walked the user through the Google Apps Script parts it could not do itself. Version one was working after about two hours of planning and building, with extra features added over a few more hours.
@ShinghiD [Claude Code]
https://x.com/ShinghiD/status/2120683981016588672
A parent set up a locked-down Linux machine for a child, with Claude Code on another PC doing the setup over Tailscale SSH and the parent approving each step. The kid gets a non-admin account on full-disk-encrypted Omarchy, a dock with only Files, Terminal, Calculator, Writer and a Claude shortcut that opens a terminal in the project folder in auto permission mode. Each project folder has a CLAUDE.md requiring kid-safe content, asking the parent before any npm install, no accounts or online servers, and teaching before building. The browser only allows localhost, DNS is filtered for the whole machine, and a Snapper snapshot is taken before every change.
@zonbi [Claude Code]
https://x.com/zonbi/status/2120767730249068885
A non-developer use case from Japanese fan communities. When people buy event merchandise on behalf of friends in their social circles, tracking who wants what, how many and at what price gets messy fast. The user had Claude Code build a small web app called Daikou-san (a proxy-buying helper) to manage exactly that, with CSV download. It is the kind of tool that would never get built as a startup and takes an afternoon with an agent.
@imaadmalikk [Claude Code]
https://x.com/imaadmalikk/status/2120845524475465747
A sales-call-to-proposal pipeline where Claude Code drafts and updates the CRM through MCP but never sends anything. The rules are what make it work: use the client's own words for the problem and its cost, never invent a price but price from a written rulebook (fixed price, 50% upfront), never discount but trade scope by suggesting a smaller first phase. Pick one proof point matched to the client's industry, and if something is missing from the call, ask once in a single message. The author's summary is blunt: without a rulebook, AI writes nice-sounding proposals with made-up numbers.
@chi3_jp [Claude Code]
https://x.com/chi3_jp/status/2120763019705950670
A home-built voice input tool designed from the start to feed Claude Code. It accepts unpolished speech, slips of the tongue included, because the user gave Claude a short list of words their dictation habitually mishears and what they really mean. The fix they are proud of is that input now lands even after switching away from the target window. The remaining wish is very specific: stop picking up sounds that are not the user talking, such as a podcast playing in the room.
@macedoh [Claude Code]
https://x.com/macedoh/status/2120680771270693132
Six months of adapting to a new Linux desktop, then 11 days of teaching it to adapt back. Linux was always configurable, the barrier was knowing how, and with Claude Code each change is one prompt away. The result is about 30 scripts in one git repo and a computer that works the user's way. It is a quiet example of the agent as a personal sysadmin rather than a coder.
@peyton_thalman1 [Claude Code]
https://x.com/peyton_thalman1/status/2120986214979588453
A game built in 45 minutes for an eight-year-old brother-in-law, who then played it for ten hours. The author wrote up exactly how it was made and published a prompt that sets everything up in Claude Code and builds a custom game for a specific kid. The value is the target audience of one: a game shaped around one child's interests is something no store can sell. It also shows that the bar for a hit is engagement from the person it was made for, not polish.
@YR195 [Claude Code]
https://x.com/YR195/status/2120975729097904564
A first published video game, vibe coded over a month with Codex and Claude Code. Cluster Tycoon is pitched as Settlers of Catan but nerdier, with an arcade twist. It is a reminder that the shipping threshold for a hobby game has dropped to a month of evenings. The interesting part is less the game than the fact that two agents were used side by side for one personal project.
@p7nnm [Claude Code]
https://x.com/p7nnm/status/2120714302294569416
A breakdown of Snag, an app for finding free items nearby, which reached $30,000 in monthly recurring revenue in about four months. The developer sketches screens in Figma around how to show the app's value in three seconds, hands the design to Claude Code inside Cursor for the front end, and uses Supabase for the backend. After launch, Mixpanel tracks onboarding, Superwall tests paywall variants and Loops emails churned users. Ads started with a creator video that had passed 50,000 organic views, scaled from $50 to $300 a day, and were reworked once about $3,000 on that one asset stopped paying back.
@starwardshar [Claude Code]
https://x.com/starwardshar/status/2120896146453238184
Four abandoned side projects revived with no new ideas, going from about 1,000 visitors a month in July to about 26,000 across all four, with one site now getting most of its traffic from ChatGPT. What moved the numbers was unglamorous: old domains of four and seven years, fixing a missing page that 60% of one site's search impressions pointed to, and pages that answer the exact mid-task question people ask an AI. Two sites came off Webflow onto a custom setup. Each project keeps its own long-running Claude Code session that already knows the code, data and past decisions, so work goes straight to shipping instead of re-explaining.
@kokasexton [Claude Code]
https://x.com/kokasexton/status/2120682754291724716
A fully autonomous website running on five Claude Code skills: research, writing, publishing, and analysis of GA4 and Search Console data. A new post goes out every day. The agents also retrofit old articles based on SEO and AEO data, rather than only adding new ones. The user reports it is working, and the retrofit loop is the part most content automations skip.
@illyism [Claude Code]
https://x.com/illyism/status/2120724849576317287
A practitioner fed an entire raw work archive into a swarm of Opus and Gemini agents to build 30 open-source SEO skills. The input was private: more than 10 hours of recorded SEO calls and strategy sessions, more than 130 recorded videos, daily SEO and git journals across the author's own products, and more than 500 link-building campaigns. Every skill was cold-tested against a live Next.js 16 sandbox before shipping. They install with one command into Claude Code, Cursor or Codex, which turns years of tacit know-how into something an agent can run.
@VamsiBuilds [Claude Code]
https://x.com/VamsiBuilds/status/2120798215545245771
Eighty SEO skills for Claude Code that contradicted each other, some pushing keyword density or FAQ schema, others saying none of that works. The author had Claude watch every SEO, AEO and GEO course they could find using a self-built tool, then study all 80 skills, merge about 25 groups of duplicates, settle the contradictions and rebuild everything as one skill. It now reads Search Console data, checks whether a Google update hit, finds the pages losing traffic and says what to fix this week. Three rules make it trustworthy: it never invents data, never grades a page it did not read, and ends every report with what it did not check.
@Yoroomie [Claude Code]
https://x.com/Yoroomie/status/2120684762994278491
A marketplace directory business moved its whole site off Webflow after a few days of building with Claude Code. It now runs on a fully custom platform built on Astro, Sanity and Vercel. The notable thing is the speed of the exit: a no-code platform migration that used to be a quarter-long project took days. The team says bigger updates are coming on the new stack.
@bolau_ [Claude Code]
https://x.com/bolau_/status/2120917378540138707
The most used internal tool at Extend started as a voice note recorded on a Facebook Marketplace Peloton. The growth lead built the company's GTM brain with Claude Code, and the company shared how it was put together. It is a non-engineer building the system the sales and marketing side relies on every day. The detail that the idea began as a voice memo on exercise equipment is a good reminder that specs no longer need to start in a document.
@AgileAlliance [Claude Code]
https://x.com/AgileAlliance/status/2120879285938589899
An agile coach uses Claude Code Insights to run a retrospective on recent AI-assisted work. It reviews the work, finds recurring failures and suggests updates to the team's working agreements. When a release rule is violated, the coach traces the conflicting instruction that caused it, fixes it and changes the process. The useful output is not a scorecard but a changed way of working, which is the old agile loop with new participants.
@JLawDex [Claude Code]
https://x.com/JLawDex/status/2120879311582634053
A one-prompt audit of where building effort actually goes: 402 commits in 60 days, and only 12 of them went to businesses that were already running. The prompt asks Claude Code, with the gh CLI installed, to count commits across all repos and split them into agent upkeep, products with no customers and live businesses, then chart it. It is a mirror more than a tool. For people whose agents make shipping effortless, the uncomfortable question is whether the shipping is going anywhere that earns.
@aero_iki [Claude Code]
https://x.com/aero_iki/status/2120697966696837360
A small habit for keeping humans in the loop on design. The user is making promo videos from past development cases and keeps revising the design based on feedback after publishing, with Claude Code helping on the design. The trick is having Claude Code also build a local web page that shows the current design at a glance. That way a person can check it and give instructions immediately instead of reading through files.
🗣 User Voice
User Voice
Show me where the money goes before the bill does. @plusxbt and @HarryTandy found subagents and the Explore agent quietly running on the main model, @0xDodam and @ivy0xbt posted fixes for the same leak in Korean and English, @harrisonju measured the one-hour cache cliff, and @deweytn says Fable 5.2 burns a day of tokens in three or four prompts. People want per-subagent cost and cache state visible by default, not discovered in /usage afterwards.
Context should survive a session, a tool switch and a usage limit. @itsharmanjot says they lost the same context 200 times this year moving from Claude Code to Codex, @chainnotsaw_man wants skills and context that travel across devices and cloud sessions, and @realjaymes keeps everything in owned files so another agent can pick up the moment a limit hits.
Done should mean verified, not announced. @sonuv_dev asked for one bug fix and got 23 modified files with all tests passing, @just_dennie tells every new engineer that an agent's success report and actual success are two claims, @brandononchain notes a rules file is a request while hooks and deny lists are the lock, and @dng_notes warns that a denied permission call does not mean the job got done.
Convenience settings should not leak secrets. @BuildNotBoughtV and @keaiMM33 walk through how choosing don't ask again can save a full command, password included, into a local settings file that ends up on public GitHub, and the asked-for fix is pattern rules by default.
Agents need room to work. @richgel999 dedicates a 2 TiB SSD to Claude Code temp and work directories and can fill it in a couple of days, and @Ashe_Oro runs Claude Code and Codex as subagents on another agent's Linux machine to stretch usage limits.
Show me where the money goes before the bill does. @plusxbt and @HarryTandy found subagents and the Explore agent quietly running on the main model, @0xDodam and @ivy0xbt posted fixes for the same leak in Korean and English, @harrisonju measured the one-hour cache cliff, and @deweytn says Fable 5.2 burns a day of tokens in three or four prompts. People want per-subagent cost and cache state visible by default, not discovered in /usage afterwards.
Context should survive a session, a tool switch and a usage limit. @itsharmanjot says they lost the same context 200 times this year moving from Claude Code to Codex, @chainnotsaw_man wants skills and context that travel across devices and cloud sessions, and @realjaymes keeps everything in owned files so another agent can pick up the moment a limit hits.
Done should mean verified, not announced. @sonuv_dev asked for one bug fix and got 23 modified files with all tests passing, @just_dennie tells every new engineer that an agent's success report and actual success are two claims, @brandononchain notes a rules file is a request while hooks and deny lists are the lock, and @dng_notes warns that a denied permission call does not mean the job got done.
Convenience settings should not leak secrets. @BuildNotBoughtV and @keaiMM33 walk through how choosing don't ask again can save a full command, password included, into a local settings file that ends up on public GitHub, and the asked-for fix is pattern rules by default.
Agents need room to work. @richgel999 dedicates a 2 TiB SSD to Claude Code temp and work directories and can fill it in a couple of days, and @Ashe_Oro runs Claude Code and Codex as subagents on another agent's Linux machine to stretch usage limits.
📡 Eco Products Radar
Eco Products Radar
Codex: the constant companion, run side by side with Claude Code in Rider Air, T3 Code, Rowboat, Omnigraph tests and portability setups.
Cursor: the third seat in most multi-agent setups and the editor in the Snag and ramen-stall comparisons.
Grok Bot: used as an orchestrator or messenger that drives Claude Code sessions.
Blender: the renderer behind the short film, the ramen stall and several Claude-drives-Blender skills.
T3 Code: one app for many Claude, Codex and Cursor accounts and machines.
claude-mem: the most cited memory layer for carrying context across sessions and tools.
Multica: a board where people assign tasks to coding agents like teammates.
Plurai: agent simulation and testing that runs inside Claude Code, Codex or Copilot.
Modern Web Guidance: browser vendors' skill bundle that teaches coding agents current web features.
Hermes: a fellow agent teamed with Claude Code in multi-agent demos.
Obsidian: notes as agent memory you own.
Codex: the constant companion, run side by side with Claude Code in Rider Air, T3 Code, Rowboat, Omnigraph tests and portability setups.
Cursor: the third seat in most multi-agent setups and the editor in the Snag and ramen-stall comparisons.
Grok Bot: used as an orchestrator or messenger that drives Claude Code sessions.
Blender: the renderer behind the short film, the ramen stall and several Claude-drives-Blender skills.
T3 Code: one app for many Claude, Codex and Cursor accounts and machines.
claude-mem: the most cited memory layer for carrying context across sessions and tools.
Multica: a board where people assign tasks to coding agents like teammates.
Plurai: agent simulation and testing that runs inside Claude Code, Codex or Copilot.
Modern Web Guidance: browser vendors' skill bundle that teaches coding agents current web features.
Hermes: a fellow agent teamed with Claude Code in multi-agent demos.
Obsidian: notes as agent memory you own.
Comments