Super User Daily: 2026-09-10
Today's feed splits cleanly in two. On one side, people are no longer running one agent - they're running fleets, and the hard part has stopped being the model and started being routing, landing and counting. One builder is coordinating 25 agents across five harnesses from a single terminal with a watcher loop and a rule that no agent ever pushes. On the other side, the bill finally came due: a three-day session quietly grew to a million tokens of context and burned 85% of a weekly allowance in one day, and Anthropic shipped commands that let Claude Code audit and cut its own cost. The non-coding cases were the best they've been in weeks - an hour of a daughter's home video cut into a highlight reel for $1.50, a family's school emails turned into a printed newspaper, a decade-long sharpening business, a tax-document pipeline. And two agent-safety incidents landed the same day: a Notion MCP that tells your agent to advertise Notion and never explain why, and an image that makes an agent rewrite its own tools file.
@HasanmMattar [Claude Code]
https://x.com/HasanmMattar/status/2097244160906403856
Runs three companies entirely through Claude Code with custom agents, structured as 24 standing workflow loops rather than one-off prompts. Each loop gets a goal, a way to score its own work, and permission to keep retrying for 24 hours until the number moves: one loop is told "you are ranked 30th for this keyword, run monthly, make the edits yourself, keep going until page one"; another is told "you are spending $100 a day and losing money, test creatives, kill what doesn't convert, continue until the account is profitable"; a third is told "output accuracy is 88%, keep changing instructions and models until it clears 90%". His argument is that prompt engineering had about an 18-month life and has been replaced by workflow engineering, and that every loop only works because it terminates on one unambiguous metric.
@andrebrov [Claude Code]
https://x.com/andrebrov/status/2097134891833917946
Runs roughly 25 coding agents across five harnesses from one terminal console, organised like a team rather than a chatroom - each agent has a role (coder, reviewer, judge, design, PM, SRE, architect) and its own git worktree, and no agent ever pushes; one lead lands. Work is a markdown file committed on main, not a chat message, because an issue that isn't on main is invisible to agents in worktrees - he lost 23 issue files on one branch for hours learning that. Every rule in his watcher loop came from an incident: a model never reviews itself, an unrouted DONE goes to a retry lane instead of the void, a harness that's out of credits never gets dispatched to (one ran dry and idled 10 seats for 40 minutes unseen). He judges progress only by artifacts - commits since dispatch, last-commit age, report file mtime - because fleet status says "done" while an agent is mid-turn. Cost: one 16-core box at load 350, and a lead whose job is routing and counting rather than coding.
@G_Programming [Claude Code]
https://x.com/G_Programming/status/2097419142265540674
Kept a single Claude Code session alive for three days doing releases and infra work, and the context quietly grew to nearly a million tokens with no warning from the tool. A monitoring task pointed at Grafana meant the main thread made 537 requests in one day, each re-reading roughly 690,000 tokens of context - cached, but still a real bill - and it ate 85% of his weekly subscription with four days left before reset. His point is that the model did exactly what he asked and the tooling let him walk straight into the wall with no visibility: he wants context size and per-turn cost in the status line before he presses enter, a prompt to compact past a threshold, and background monitors that don't turn every notification into a full-context turn. Priced at API rates the session would have been around $1,615.
@NotZainAgain [OpenClaw]
https://x.com/NotZainAgain/status/2097150500038725895
Logged what a personal agent actually got done for him in real life, and none of it was code: booked 70mm IMAX tickets at a specific NYC theater, paid off a 2024 Swiss speeding ticket he'd been avoiding after trying to negotiate the late fees down, found a $54 Groupon for a dental cleaning and booked the appointment, bought a wedding gift for a friend whose wedding he couldn't attend, and cancelled two subscriptions billing a card under an email address he'd lost access to. The best detail: on one cancellation it went back and forth with a customer service agent that was also AI, both sides firing off instant essays, until the other agent gave in. His read is that this is the first one simple enough to hand to his parents, and that the power-user harnesses are heading for a narrower audience.
@VincentSkywalke [OpenClaw]
https://x.com/VincentSkywalke/status/2097244513433477430
Has been recording his daughter's daily life on an Osmo since she was born - years of huge high-definition files he could never face editing, because documentary-style daily footage is the worst kind to cut: you have to rewatch every second of raw material to pull ten usable minutes. He handed one hour of a single day's footage to an agent and got a tight 15-minute highlight reel back in 20 minutes, with frames pulled, scenes understood, captions generated, transitions and overlays added. It used 3% of his weekly quota, about $1.50. He'd previously spent weeks hunting freelance editors on Xianyu and couldn't find anyone to cut a single video for 1,000 yuan.
@AI_RemoteWorker [Claude Code]
https://x.com/AI_RemoteWorker/status/2097120263993512141
Handed 19 sales tasks to Claude Code and cut a 14 hour 55 minute week down to 54 minutes - and then reports the part almost nobody publishes: for the first two months, the number of sales meetings did not increase by one. His diagnosis is that he never decided in advance what the freed-up time was for, so it simply evaporated. He's written up which tasks he automated and in what order, but the honest headline is that time savings and pipeline are two different metrics and automating the first does nothing for the second by default.
@mylifcc [Claude Code]
https://x.com/mylifcc/status/2097377395766706493
Walks through the three new /claude-api commands, which are notable because they point Claude Code at optimising Claude's own cost. prompt-audit scans your prompts, CLAUDE.md, skills, tool descriptions and any application code calling the API, and strips out patterns that helped older models but now actively hurt: "double-check your work", "verify twice", "be maximally thorough", "CRITICAL: YOU MUST ALWAYS", forced step-by-step, mandatory scratchpads, stale few-shot examples. Newer models take these literally - "verify twice" makes them genuinely run the query twice, and "be maximally thorough" triggered dozens of unnecessary knowledge base searches. On an Opus 4.8 to Opus 5 migration, a single audit run cut cost 14.6% and raised accuracy 5.3%. hillclimb goes further: given an eval it splits train/test, changes config, reads the failures and iterates - it took a customer support benchmark from 78.6% to 90.5% at roughly one fifth the cost, and notably it did that by stepping down to a cheaper model and then adding routing rules to recover the accuracy, not by reaching for a bigger one.
@HelloVyom [Claude Code]
https://x.com/HelloVyom/status/2097239916988309988
Reports someone landing two job offers from a job search engine built on Claude Code that read more than 10,000 postings against a single resume and shortlisted 190 of them. It's a small note but it's the clearest example this week of the pattern that actually works for non-engineers: pick a task whose volume is the problem, not whose difficulty is, and let the agent grind it.
@xmayeth [Claude Code]
https://x.com/xmayeth/status/2097353166698504674
Built his Polymarket strategies on two free public data services and says they pay him around $10,000 a month, with Claude Code as the query layer - he asks a question about the market in plain words and it digs through the data and comes back with numbers. The first service syncs every Polymarket trade to your own disk (his first sync pulled 3.1 million markets and ran for hours overnight; updates land in seconds after that), including who bought, when, at what price, and who was on the other side. The second holds the order book itself second by second - 288 billion events recorded, 2.3 billion more per day - the kind of data he used to pay $200 a month for. He notes the archive runs on donations and one person is carrying the storage bill.
@bprintco [OpenClaw]
https://x.com/bprintco/status/2097163367987151183
Answered a question most people running an AI-heavy business are quietly avoiding: is a company built on agents sellable, or is it trapped with whoever built it? When he started his major agent build he required the agents to log agent-readable SOPs as they worked, specifically so he could point any harness at them later. This week he tested it by moving his entire AI stack off one harness onto another - a highly complex system for a home services company - and the SOPs carried it over cleanly. He pointed the new harness at them and it set itself up and took over. It burned $200 doing it, which he calls irrelevant next to what it proved.
@masaru21 [Claude Code]
https://x.com/masaru21/status/2097146555526676486
Caught a genuinely dangerous near-miss during PR review. The task was supposed to add a handful of files, but his working directory was in a sparse-checkout state, so thousands of files came through the commit marked as deletions. The scary part wasn't the deletions - it was that GitHub only surfaced a few of them as conflicts, so if he had fixed just the conflicting files and merged, every non-conflicting file would have been silently deleted. His conclusion is that "did it fix the thing" is not enough of a check: you have to look at git status, diff --stat, diff --name-status, the sparse-checkout state, and above all whether the number of changed files matches what you expected. He now recommends a rule in AGENTS.md that halts automatically when a five-file task produces hundreds or thousands of diffs.
@notEgoyard [Claude Code]
https://x.com/notEgoyard/status/2097282920016687610
Describes a design review loop from someone who has shipped design for Adobe and IBM for 29 years, and the thing that finally changed his workflow wasn't prettier output - it was Claude reviewing its own work as a second person would. Claude Code builds the app first, from a one-line prompt to a working dashboard with filtering, sorting, empty states and edit dialogs. Then Playwright MCP takes over: opens a real headless browser, navigates every screen, screenshots each one. A design review skill then runs against those screenshots autonomously - no pasting, no "does this look right?" - and caught sparse layouts, incorrect chart ordering, missing dark mode handling and accessibility gaps, the class of problem a solo builder stops seeing on their own screen. It proposes specific fixes and can apply them in the same session.
@sonicdr1p [Claude Code]
https://x.com/sonicdr1p/status/2097291987531538914
Argues most people run Claude Code wide open until it starts hallucinating file paths, then blame the model instead of their own context window. His main tip is to run /clear far earlier than feels necessary - around 20-25% of context capacity rather than riding it to the edge - citing retrieval accuracy dropping to roughly 78% near max context versus 91-92% running lean, which is the difference between remembering a constraint you gave three files ago and quietly inventing something. The rest is about killing dead time: swap MCP servers for plain CLIs where you can, since a CLI runs straight in the terminal and burns fewer tokens per call than a protocol layer for the same result; use /btw to fire a side question into a running task without spending context; and in plan mode, stop asking Claude to finish the plan and instead ask "what am I not thinking about" and "what would actually break this".
@Piste_AI_BOSS [Claude Code]
https://x.com/Piste_AI_BOSS/status/2097293084103004224
Six months of running Claude Code and Codex side by side, written up as a working arrangement rather than a verdict. The core move is refusing to switch: put both extensions in one editor sharing the same working folder, so either can read what the other wrote, your skills stay usable from both, and you can change engines mid-task without changing screens. The role split that kept recurring in practice: deep research in ChatGPT saved to a markdown file and handed over, building and sequencing in Claude Code, and when the same error survives three attempts, paste it into the Codex chat pointed at the same folder. His biggest single time saving was image generation - he used to build the spec in Claude Code, copy it into ChatGPT by hand, download images and wire them in, about an hour; now he passes the spec path and the folder path and it's five minutes, with one caveat: say "create a new file" or it will overwrite live working files. He also warns against over-combining: only run two tools when they have clearly different strengths in the same folder, otherwise you just add a window you stop opening.
@RishiUvaach [Claude Code]
https://x.com/RishiUvaach/status/2097316525359223121
Stopped using the Claude chat app six months ago and moved almost everything into Claude Code, with a mapping that makes the switch legible to non-developers: a project is just a folder you open and run claude in; standing instructions go in ~/CLAUDE.md with /init run once; project rules go in a second CLAUDE.md inside the folder; your files are already there and get referenced with @filename; connectors carry over; prompts you keep repeating become skills triggered by one word; research goes to subagents by saying "use subagents"; /memory lets you inspect what Claude is remembering; a fresh chat means writing HANDOVER.md then /clear; a rule Claude keeps forgetting becomes a hook so following it isn't optional; anything you do every Monday goes on /schedule and runs with your laptop shut. His framing is that projects, instructions, files, connectors, reusable prompts, research, memory and automation are all things chat users already use - Claude Code just puts them in a working environment instead of another conversation window.
@fuji_ai_ [Claude Code]
https://x.com/fuji_ai_/status/2097248926252576870
A full-time trader with ten years of experience and zero coding background wired Claude Code to TradingView over MCP and automated his morning stock selection. Claude reads the charts directly and draws on them: 52-week highs and lows plus the previous day's high and low get plotted automatically, and every morning it pulls stocks that gapped more than 5% against the prior close, filters to price above $3 and pre-market volume above 50,000 shares, and saves the result as JSON with a one-line news catalyst attached. The only requirements are paid Claude and TradingView plans and the desktop version of both.
@DaviddDotTech [Claude Code]
https://x.com/DaviddDotTech/status/2097239265285411077
Re-tests every trading strategy he's watching once a month, and says the 20-minute check has saved him from funding dead strategies. The loop runs in Claude Code with a backtesting tool connected: list every strategy marked for forward testing with its pair and timeframe; re-backtest each on the same pair and timeframe with fees on and the last 30 days included; put the results next to last month's and say plainly whether profit factor is sliding, drawdown growing or win rate falling; bin the decayed ones with the reason recorded; fund only the survivors, with a bar of 20 minimum forward-test trades and every monthly check passed. His line is that every strategy dies eventually and this is how you find out before your money does.
@MystiqueMide [Claude Code]
https://x.com/MystiqueMide/status/2097474244095451324
Built a verification-first trading agent around a rule worth stealing regardless of the domain: if the exchange can't prove it, the agent can't claim it. Before an order is placed, the agent's intent becomes a strict claim with a unique ID, and the harness - not the model - places the order and stamps that ID into the exchange's own order record. It then reads the order back twice, once by exchange order ID and once by the claim ID, and both readbacks have to agree before it checks the claim field by field. Only then does it return PROVED; if the exchange can't prove it, the session locks immediately and a human has to recover it. The restriction is the interesting part: the platform exposes 366 tools, the agent is allowed 6, and the LLM itself gets zero tools - it proposes, the harness validates and executes, the exchange verifies. He also built a zero-cost demo mode that places a below-market dust order, proves it exists, cancels it and reads it back to confirm nothing executed.
@Himess__ [Claude Code]
https://x.com/Himess__/status/2097447601033355356
Built a portfolio rebalancing agent and the headline result is a refusal, not a trade. On one historical date two positions breached the same tolerance band; it bought BTC and refused to buy AVAX because AVAX was still falling. Same check, different answers, reproduced across three independent runs - a threshold bot fires both. The architecture behind it: the model picks and explains but never computes, with every quantity, price and percentage produced by deterministic TypeScript and the prose written with placeholders the server fills in, so if the model types a bare figure anywhere the entire response is discarded. Against a threshold bot over one year with identical data it matched tracking at 22% less cost. One useful incidental finding: the exchange's MCP tool list paginates at 50, so a naive capture sees two-thirds of the surface and looks complete - following the cursor gives 81.
@twtayaan [Claude Code]
https://x.com/twtayaan/status/2097295188683055343
Tested the question most people are avoiding - what happens when you let an agent touch infrastructure - by giving it a deliberately narrow path. He connected Claude Code to an orchestration platform over MCP and built one workflow: validate, human approval, deploy, verify. Claude never touched the cluster directly; it called a flow, and the flow held the actual access while one step still required him to say yes. The deployment checked the current version, paused for approval, deployed once he approved, and then verified the rollout actually succeeded. His takeaway is mostly emotional and mostly correct: watching a deployment stop and wait before touching Kubernetes was the reassuring part.
@codyschneider [Claude Code]
https://x.com/codyschneider/status/2097369443344994336
Lays out how to audit the agency running your Facebook ads instead of taking their word for it. Get Google Ads, PostHog and CRM data into a warehouse, give Claude Code access to that warehouse plus an S3 bucket, then pull all your ad creative with its conversion data and have a vision model analyse the creative, the ad text and the landing pages into a database. Claude Code then analyses that database to find what's working, and with a Facebook Ads API key it can modify campaigns from the analysis - losers off, winners promoted - closing into a creative velocity loop. He posted a parallel version for Google Ads the same day, where the specific win is auditing search terms for wasted spend and negative-matching intent that doesn't fit the product.
@fivosaresti [Claude Code]
https://x.com/fivosaresti/status/2097324082119254447
Runs cold email for clients at millions of sends a month and uses Claude Code specifically for the last mile, with a method that solves the usual quality collapse. Pick five genuinely different angles - five separate reasons the account should care. Then write exactly one email by hand, fully personalised; that email is the quality bar the machine copies. Feed Claude Code a summary of each company plus that hand-written example, per row, and it produces a tailored variant for every account across both motions, then uploads the campaign variants straight into the email and LinkedIn tools. His framing: write one well, then let Claude Code hold the bar across every row.
@coldemailchris [Claude Code]
https://x.com/coldemailchris/status/2097310103527670032
Built an entire cold email campaign for his own company live on camera to test whether the skills hold up, having launched over 2,000 campaigns for clients. The pieces that did the work: a market research skill that produced 19 pages from a single URL, TAM mapping that ranked every segment worth going after, an ICP skill that surfaced personas his team had never written down, and lead sourcing that turned up databases Apollo doesn't have. The list itself was built by an agent from a Slack message.
@hanifproduktif [Claude Code]
https://x.com/hanifproduktif/status/2097378992718512632
Ran the same automated carousel content through Instagram, Facebook and TikTok and got wildly different results - 180,000 Instagram followers in a month, and on Facebook not a single carousel cleared 100 impressions. Rather than abandon the content he rebuilt it as video through Claude Code: images from an image API, voiceover from ElevenLabs, editing in FFmpeg, with Claude writing the script, generating per-scene images, finalising the video and even posting it with the caption through a scheduling connector. He explicitly chose this over a video generation model on cost - a 40-60 second explainer would have run him around 100,000 rupiah per video there, versus $0.85 with this pipeline, which is what lets him ship four a day. His warning to anyone doing AI content: watch the per-unit cost obsessively, especially before you've monetised.
@maxxmalist [Claude Code]
https://x.com/maxxmalist/status/2097352345273139604
Boils AI content automation down to three steps and insists it's not worth overcomplicating: write down your manual workflow with links to the tools, paste it into Claude Code, and give it browser control. If you use several ad styles, give it several workflows. The one non-negotiable is watching it run the first time and iterating on the steps before letting it run in the background. He notes Claude is surprisingly good at understanding the visual intent and generating new first frames when needed, will check its own work to make sure scenes generated correctly, fix the script when a generator refuses something, and cut and stitch the scenes together if you ask.
@euboid [Claude Code]
https://x.com/euboid/status/2097309908664238344
Handed a finished component library and design file to Claude Code and had it implement and verify the whole thing end to end using a planning model with subagents underneath. This was part of a full brand and site redesign - brand language, landing page, component library, motion, social assets - taken from design file to shipped code in about two and a half days, which is the more interesting number than the tooling.
@oiharshit [Claude Code]
https://x.com/oiharshit/status/2097350325288202542
Rebuilt his agency site off Framer onto Next.js and used Claude Code for the interactions and to implement new sections directly from his Figma designs. The part worth noting is what he built alongside it: an admin panel where he drags and drops designs, customises them, and has them appear on the site automatically, including generating showreels of his work from the same panel. Total: four days, roughly 18 hours.
@thepixelgeek [Claude Code]
https://x.com/thepixelgeek/status/2097425676601274497
A three-step site rebuild worth copying for the last step: redesigned the site in Claude's design tool, told Claude Code to deploy that design, then dragged two CSV files exported from Webflow into Claude Code to replace the placeholder content. The content migration - usually the tedious part that kills these projects - was a drag and drop. He's now planning to point agents at it to keep content and search visibility fresh.
@exteedesign [Claude Code]
https://x.com/exteedesign/status/2097209474973155563
Replicated Apple's new timer UI using Figma plus Claude Code and reports it one-shot. Small, but the useful signal is which half of the work the design file is doing: with the visual spec pinned down, the implementation stopped being the iterative part.
@hiroccck [Claude Code]
https://x.com/hiroccck/status/2097193667681464680
Hit a specific, unglamorous failure mode: asking Claude Code to edit Figma over MCP meant Claude couldn't see his local fonts, and things it touched started behaving oddly. Instead of working around it he built a plugin that makes the environment Claude sees match the environment he sees, and says it went from stressful to frictionless. He's still asking whether this was already solved and he just missed it - which is itself the honest state of MCP tooling right now.
@tousigatizei [Claude Code]
https://x.com/tousigatizei/status/2097192180620366178
Built his first internal company app with Claude Code and went from requirements definition through design, development, testing and rollout in two hours - work he estimates would have taken two weeks at best before. His own caveat is the useful part: app development itself has become something anyone can do, but business requirements definition, security, and actually driving adoption on the ground are all still human jobs.
@hyuki [Claude Code]
https://x.com/hyuki/status/2097148300784992429
Is running projects co-managed by Claude Code and Codex and finding that the interesting failures are organisational, not technical. Going from one agent to two exposed assumptions that had been invisible: his internal message board addressed messages to a project, which worked fine when one agent owned that project, but there was no way for the deputy to send a message to the lead - fixed by addressing per-agent instead of per-project. While reorganising that, the second agent found genuinely ambiguous wording in the existing skills that the first had been quietly working around. He notes this is exactly the human org pattern where a new hire questions what everyone else stopped seeing.
@irodorimemory [Claude Code]
https://x.com/irodorimemory/status/2097193940000878827
Automated the Discord announcements her course staff had been posting by hand, and the interesting part is the design decision. Her first instinct was to auto-post from her PC, then she asked the obvious question - what if the laptop is closed at announcement time? - and moved it to a repository workflow that fires on a schedule instead, so nothing depends on her machine being awake. She did the whole thing by talking through it with Claude Code without writing code, and notes that even for a simple scheduled bot there turned out to be several quite different ways to build it. Her framing: small automations are worth it when they remove the job of a person having to remember.
@SebastianRoehl [OpenClaw]
https://x.com/SebastianRoehl/status/2097262735700394034
Sketching out the parts of his tax paperwork that are still manual, which reads as a clean spec for what personal agents should actually be doing. Invoice fetching is an annoying mix of digging through email and downloading from vendor portals one by one - the obvious candidate for a bot. Bank statements he downloads from each bank and uploads to his own app, which extracts the transactions with a model. Getting it all to his accountant is the piece he hasn't solved; he's leaning toward a password-protected export on his own VPS. He also keeps a "random" bucket for tax-relevant documents that aren't invoices or bank records, like private health invoices, which need to be in the export too.
@shao__meng [Claude Code]
https://x.com/shao__meng/status/2097141170577289708
Breaks down a coding-agent team configuration tool Tencent open-sourced after running it internally for six months, which targets a real problem: one person's hard-won workaround stays in their local session while everyone else re-hits the same wall. It uses a git repository as the single source of truth for skills, rules, hooks and MCP config, and a session-start hook pulls the merged result into each member's local Claude Code, Codex, Cursor and a dozen other tools, translating one declaration into each tool's native format. The clever part is the write side: it only prompts you to turn a session into shared knowledge if there was friction in it - you interrupted the AI, rejected a tool call, or it retried and failed - so a smooth session generates no noise. Add a weekly digest of token usage and intervention rate, promotion of high-value notes into formal skills, and cleanup of stale ones, and the loop closes.
@_avichawla [Claude Code]
https://x.com/_avichawla/status/2097242863964958760
Cut Claude Code from 10.4M tokens, 10 errors and $9.21 down to 3.7M tokens, 0 errors and $2.81 on the same build by changing the backend context layer. With the previous setup, tables, RLS policies, auth providers, storage buckets and edge functions were each retrieved through separate calls, and every response stayed in the conversation history so later calls carried more and more context. The replacement returns the whole backend topology in one metadata call of roughly 500 tokens. Its instructions are also split into narrow skills for CLI operations, debugging, SDK usage and integrations so only the relevant ones load, and the CLI returns structured JSON with semantic exit codes, making it clear whether a failure came from the operation or the code - which killed several retry loops on its own.
@BharukaShraddha [Claude Code]
https://x.com/BharukaShraddha/status/2097325394437525522
Points at a token cost most people don't attribute correctly: every time you ask Claude Code to touch unfamiliar code it spawns explore agents that grep, glob and read their way through the repo, and every file scan is billed again. The fix she's using pre-builds a local knowledge graph of the codebase - symbol relationships, call graphs, structure - so agents query the graph instead of scanning from scratch. Maintainer benchmarks across real codebases report roughly 35% cheaper per task and about 70% fewer tool calls, entirely local with no API keys, and git hooks keep the graph in sync on every commit so it doesn't go stale. Her distinction is sharp: compression tools cut the tokens you send, this cuts the tokens you never needed to burn.
@claudecode84 [Claude Code]
https://x.com/claudecode84/status/2097234685072183527
Flags /skill-doctor, which answers a question people have been guessing at: it shows which skills are actually loaded into the current session, which are loaded but never used, and how many context tokens each one is costing. Anyone who has been stacking skills has been deciding by feel whether a given skill is worth keeping and what's eating the context window. The workflow is now mechanical - run it, find the heavy skills, delete the unused ones, and the context gets lighter.
@AiAircle34052 [Claude Code]
https://x.com/AiAircle34052/status/2097276007887917307
Covers a hackathon winner open-sourcing his entire Claude Code setup under MIT, and the numbers are absurd on purpose: 68 subagents covering planning, review, build repair, security and design, 286 skills spanning TDD, per-language packs, CI/CD and even writing technique, 94 commands, plus OWASP scanning and injection checks on the agent configs themselves. The workflow underneath is simple - plan before building, write the failing test first, then have it review its own diff from a completely fresh context. The framing is that you stop using Claude Code as one assistant and start running it as an engineering organisation. The most useful line is the author's own warning: installing all 286 skills at once is the most reliable way to make things worse. Start with one planning agent and one rules pack.
@NainsiDwiv50980 [Claude Code]
https://x.com/NainsiDwiv50980/status/2097330984543006912
Spent months blaming the model every time Claude Code built the wrong thing, assuming he needed a better prompt, and concluded he actually needed to say what he wanted. The skills repo that fixed it has a most-popular skill that writes no code at all: it interviews you, and keeps asking about your plan until every branch of the design tree is resolved before any work starts. The others he reaches for run a real red-green-refactor loop with the failing test first, gate debugging phase by phase instead of letting the agent guess, and split code review into standards and spec as two separate subagents so neither pollutes the other. He's also honest about the limits - the architecture-improvement skill is a survey, not a rescue: on an old codebase it hands you real candidates and then stops.
@om_patel5 [Claude Code]
https://x.com/om_patel5/status/2097129187706376212
Documents something worth checking on every connector you've installed: Notion's official MCP contains a tool description instructing the agent to advertise Notion Business mid-task, and to never explain why. The person who found it was working on something unrelated and had never asked about pricing. The ad is the least of it - a tool description is text the server injects into your context on every single call, and the model can't distinguish "here is how to use this tool" from "advertise this and hide it", so any MCP you connect can write instructions your agent treats as authoritative. Most clients never diff a tool description after you approve it, so a server can change what it injects post-install invisibly. His defences: pull the raw tools list before installing and read what it injects, diff it again after every update, log raw tool results when testing because there's usually more in there than the model surfaces, and enforce real constraints in code rather than in a prompt.
@VoidStateKate [OpenClaw]
https://x.com/VoidStateKate/status/2097305795830386726
Summarises a visual prompt injection result that should change how people think about images in agent pipelines. Researchers got frontier vision models to emit properly formatted tool calls from a malicious image - not "the AI said something weird after looking at a picture", but a model interpreting an adversarial signal no human notices and then calling tools it isn't authorised to call. They demonstrated it in a default OpenClaw Discord setup, where someone could send the agent a manipulated image and get it to overwrite its own tools file, which means the attack doesn't just land once: it edits instructions that future runs inherit. Attack success was over 80% on one tested model and 47% on another, some visual attacks succeeded where adaptive text injection failed, and attacks optimised against one model transferred to different commercial models.
@0xrux [Claude Code]
https://x.com/0xrux/status/2097211288178803006
Pushes back on the free frontier-model API keys circulating this week with the question nobody's asking: why would anyone give away frontier inference for free? The key routes through a third-party proxy rather than the model provider directly, which means that proxy sits between you and every prompt, every line of code and every file you paste in - and a service that can see your traffic can log it, which isn't paranoia, it's the definition of a proxy. Zero friction to sign up is also zero friction to forget you're routing real work through a server you know nothing about. The part that undercuts the deal before privacy even comes up: several of these proxies have been benchmarked against the real API and don't hold up, with some suspected of quietly serving a cheaper model under a flagship label.
@SKatalystAI [Claude Code]
https://x.com/SKatalystAI/status/2097391309711720726
Describes a routing layer rather than a favourite model, and the second round of his own testing produced the more interesting result. Round one gave one model the edge as an implementer. Round two had the other model review that winning implementation - and instead of rubber-stamping it, it reopened the search surface and produced a new set of failure tests. That's exactly the behaviour he wants from a reviewer or research agent, and exactly the tendency that creates unnecessary churn during implementation, which is the whole argument for splitting the roles. His current routing puts one model on implementation, repo work and surgical fixes, the other on research, adversarial review and hard problems, with a separate daily workspace and orchestration layer. His conclusion: stop paying for "the best model" and start paying for distinct capabilities that earn a place in the routing layer.
@ryanlpeterman [Claude Code]
https://x.com/ryanlpeterman/status/2097376754478551142
Burned through both his 20x weekly limits in about two days running two frontier models against each other, and posted four observations from it. The Claude allowance ran out noticeably faster than the other for his usage. One model writes much better plans for a human to read, though both one-shot his work in roughly 90% of cases. The Claude Code TUI is well ahead on product craft and user experience. And the desktop app computer use on the other side is excellent at rote tasks he previously didn't trust models to handle - which is the observation he thinks matters most for jobs built on repetitive computer work.
@iannuttall [Claude Code]
https://x.com/iannuttall/status/2097235816602820678
Posts his always-on agent rig, and the credential handling is the part to copy: a Mac Mini running Codex, Claude Code and Cursor CLI with Chrome extensions, and a password manager CLI with a dedicated service account for agent use rather than his personal vault. A terminal multiplexer plus a mesh VPN keeps sessions alive across disconnects, and a remote desktop client is there for when he needs to take the machine over himself.
@leeschmidt123 [Claude Code]
https://x.com/leeschmidt123/status/2097410111111074069
Moved off git worktrees once he got on-demand cloud VMs working and calls it a step change. His argument is that every dev environment should be ephemeral, should have its own instances of any third-party API you depend on - a payments sandbox, anything delivering webhooks - should have its own local database, and crucially should not require your laptop or home server to be online. That last constraint is the one that quietly breaks long agent runs, and he says he's not going back.
@uroborosu_ai [Claude Code]
https://x.com/uroborosu_ai/status/2097272676402569222
Documents Claude Code's remote control properly: run claude remote-control, get a URL and QR code, scan it with the phone app, and you can write into the same conversation from any device. Three conditions apply - a Pro-or-above subscription, a direct connection, and the local process has to keep running, so closing the terminal takes it offline. The point is that execution stays on your own machine, so your local files and MCP servers still work; you can send it a photo, you get a notification when a long task finishes, and if the connection drops the messages arrive together when you come back.
@RileyRalmuto [Claude Code]
https://x.com/RileyRalmuto/status/2097168775648850300
Building a shared knowledge layer across agents that tackles the handoff problem directly. On onboarding, an agent interviews you and offers to scan your machine to see what's worth bringing into an encrypted shared knowledge base; if you opt in it syncs your Codex and Claude Code session and project history, and you can then pick an existing session as the starting context for a new chat - so you flow straight into work instead of spending an hour bringing an agent up to speed. Beyond that you create project channels and choose the working context for each, so you can pull in three repositories plus seven Codex sessions and three Claude sessions, then bring several agents into that channel where they collaborate in relative isolation. He notes you can also give each agent its own room and let it fill it, and let them talk to whichever agents they like.
@0xChonsy [OpenClaw]
https://x.com/0xChonsy/status/2097335724060110865
Summarises a walkthrough from a founder running agents as something close to real coworkers, and the non-coding examples are the strongest part: scanning six inboxes every hour and surfacing only what matters, and turning school emails and calendars into a daily printed family newspaper. The engineering side clears roughly 50 stale pull requests and launches cloud agents to fix them, and support handles bugs and payment refunds with human approval. The detail worth flagging is the last one - moving an entire existing agent from one harness to another as a "brain transplant", which is the same portability question several people tested this week.
@iAmHenryMascot [OpenClaw]
https://x.com/iAmHenryMascot/status/2097161882603773973
Pushes back hard on the idea that a single-thread personal agent is enough for work, from someone running at genuine scale: at least 50 active sessions daily across a couple of self-hosted agents, plus a coding harness and a cloud agent product. He describes them as employees you hand projects to and check on during the day or the week, and his actual job as orchestrating a civilisation of agents across different companies and projects. His practical workaround for thread limits is worth noting: with the self-hosted agents you extend into many threads by using groups on WhatsApp and Telegram. Even for personal life, he says one thread is too small.
@chrsaravia [OpenClaw]
https://x.com/chrsaravia/status/2097465266967887966
Wrote the most honest assessment of self-hosted personal agents this week, from someone who bought a Mac Mini in January specifically to build one and still runs it. He genuinely loves that it's open source, that he can run it locally, inspect everything, change how it works, connect random tools, break things and fix them. And then: the product experience is not delightful enough for a general audience. Most people will never open a terminal to run an update or a doctor command, and they shouldn't have to - they don't want to manage a Mac Mini, API keys, config files, permissions and models. His prediction is that the open-source option keeps a real place for builders and tinkerers, but most people will take the packaged, hosted version with less control and far less maintenance.
@GitHub_Daily [OpenClaw]
https://x.com/GitHub_Daily/status/2097225972366114879
Covers a social media operations agent built by two university labs that runs on OpenClaw, and the architecture is more interesting than the feature list. It strings hot-topic discovery, topic planning, image and video production, publishing and review into one workflow, and maintains a profile per account - positioning, audience, style, platform constraints and historical performance - where published results are fed back into the profile so the next generation fits that account better. It ships 112 skills that are real runnable scripts producing files into a directory, covering copy, knowledge cards, posters, infographics, voiceover, voice cloning, subtitles, editing and short-form drama, with one master version adaptable per platform. Its own README warns that one target platform polices automation strictly and recommends previewing and posting manually, which is a rare piece of honesty in this category.
@okooo5km [OpenClaw]
https://x.com/okooo5km/status/2097243163723186487
Migrated his wife's personal agent twice - across three different products - and had the AI perform each migration itself, with memory, automated tasks and persona all surviving intact. His reason for the final move is a good reminder that setup friction decides adoption for most people: the destination connects to her messaging apps by scanning a QR code, which dropped the barrier enormously. He notes domestic models are now good enough for everyday office work and cheap enough that consumption is negligible, and is now considering moving his own daily assistant over.
@meijiangAI [Claude Code]
https://x.com/meijiangAI/status/2097155719493726636
Shares the exact prompt he uses to prepare a migration from Claude Code or Codex into a cloud agent swarm, which is a useful artifact regardless of destination because it's really an inventory of what a mature setup contains. It asks the agent to compile every saved skill file with a detailed summary of what each does, condense the core memory and context files into a single profile covering goals, preferences, business background and writing style, list every recurring workflow with its trigger conditions, steps and frequency, propose an agent breakdown grouping those workflows into logical roles the way a real team divides work, and flag every existing tool and MCP in use - all output as clean structured markdown.
@LukasHozda [OpenClaw]
https://x.com/LukasHozda/status/2097246224780825068
Gave an agent a Linux user on a server and an email address and told it to pay a small rent, then watched what happened. It started self-modifying - without lobotomising itself, as he puts it - and turned into a 24/7 agent that forked itself into the background and set up crons, heartbeats and listeners, and can natively send and receive email. It's an experiment rather than a product, but it's the cleanest demonstration this week of what changes when an agent is given a persistent identity and an ongoing obligation rather than a task.
@DevMiddleEarth [OpenClaw]
https://x.com/DevMiddleEarth/status/2097177193273335918
Was bored, so he spun up three agents with individually configured personalities and identities, wrote a script to hand them a hot topic, and had them debate it while logging every exchange. Not a product, not a workflow - but it's the cheapest possible experiment for anyone wondering what multi-agent disagreement actually looks like before wiring it into something that matters.
@pato_pitaluga [OpenClaw]
https://x.com/pato_pitaluga/status/2097420905487937964
Uses an agent to crawl news, but with a design choice worth noting: rather than following one outlet, it reads across many national and international news portals and then produces a ranking of which stories are likely to be most interesting. The interesting shift is that the agent isn't summarising a feed someone else curated - it's doing the curation, which is the job the feed used to do.
@XMihura [OpenClaw]
https://x.com/XMihura/status/2097332767692349600
Tried a hosted personal agent, said it works well, and uninstalled it anyway - for a reason worth taking seriously. It's essentially a well-packaged version of the self-hosted agents with computer use added, and it works fine. But he doesn't know what's behind it and has no reason to trust it, especially with something that will hold his credentials and take actions in his name. With the self-hosted options you assemble it yourself so you know what's there; with a coding harness you pick the model and actively control access; on one cloud agent product you can at least reach the VM the bots run in. Here you control nothing, which is partly the intention, and that's the part he won't accept.
@SimonHoiberg [OpenClaw]
https://x.com/SimonHoiberg/status/2097293788972507138
Argues the single best use of AI right now is building your own internal tooling and custom harnesses, and publishes an unusually opinionated stack for it: a Linux distribution plus a self-hosted agent, and explicitly not Claude Code, not a cloud agent product, not macOS or Windows, not cloud for everything, and not 19 generic SaaS tools. His framing is that after a big revenue growth year, this year has been about building sovereign company infrastructure ahead of the next few years of building with AI - which is a genuinely different bet from most of this feed.
@asindexai [OpenClaw]
https://x.com/asindexai/status/2097365192124350926
Provides the counterweight to this week's update complaints: he had his orchestrator handle a major update end to end on a heavily customised setup, including regression testing and a full-setup health check. It did need to reindex the memory for his main agent, but that went smoothly too. Worth reading next to the several people the same day reporting that asking their agent to update itself breaks it every time - the difference appears to be whether there's an orchestrator with a verification step, not luck.
@blchead [Claude Code]
https://x.com/blchead/status/2097373913517064324
Shipped an auditor skill for a mandatory blockchain transaction format change, and the failure taxonomy is the valuable part because most of it is silent. Loud failures error immediately. A wedge failure has a subscription emit null and stop advancing forever. The silent one: every indexer that finds the priority fee by scanning the old instruction type now records zero, with no error at all. And the dangerous one: a fee sponsor that caps fees by scanning instructions binds nothing under the new format, so an attacker puts the fee in the config, adds harmless no-op instructions to keep your scanner happy, and you sign - repeatedly, until the key is empty. The skill runs 23 checklist items across TypeScript, backend, off-chain, on-chain, deployment, testing and monitoring, and every item comes back PASS, FAIL or N/A with the file and line. It's a folder of markdown - nothing runs, nothing phones home.
@mervenoyann [Claude Code]
https://x.com/mervenoyann/status/2097420163968635113
Flags a result that argues for training your own orchestrator rather than renting one: a post-trained open model orchestrator raised rubric criteria pass rate from 29.9% to 63.0% on 50 held-out diligence data rooms, outperforming both Claude Code and the main competing harness on that task. Her point is that training open model agents is where the moat is, which is a direct challenge to the assumption that the general-purpose coding harness is the ceiling for domain work.
@itsalexvacca [Claude Code]
https://x.com/itsalexvacca/status/2097309883578425653
Makes a prediction with a concrete mechanism behind it: AI agents will become customers of the software they're supposed to kill. If you use Claude Code to research potential customers with a search API doing the web searches, that API already charges per search request - so asking Claude to research more companies means paying more without adding anyone to your team. His expectation is that more software companies will charge for the tasks agents run through their products rather than for seats, and that some will make more money from customers with smaller teams. If he were selling such a tool he'd make it easy for agents to use and bill for their usage, rather than waiting for the customer to hire someone so he can sell another seat.
@TDataScience [Claude Code]
https://x.com/TDataScience/status/2097418951974129922
Rebuilt a CV as a playable browser game - one HTML file, no server - generated by asking Claude Code to read the CV and make a game out of it. It's a gimmick, and it's also the clearest one-line demonstration of the class of task these tools have quietly made trivial: a self-contained artifact with a well-specified input and no infrastructure.
@itsharmanjot [Claude Code]
https://x.com/itsharmanjot/status/2097232364615451075
Built a plugin that matches you with a stranger who is also waiting for their Claude to finish - audio first, video only if you both opt in. The room opens itself when Claude runs long, and when either person's Claude finishes there's a ten-second countdown and the room closes itself. Your task never leaves your machine, it records nothing, and it only knows one thing about the person across from you: that they're waiting too. It's a joke that happens to be a precise measurement of how long people now spend watching a terminal.
@capitaltruist [OpenClaw]
https://x.com/capitaltruist/status/2097420610842636394
Has tried four personal agents as a self-described normie and arrives at a product argument rather than a ranking: he wants multiple specialised agents in his messaging app, each excellent at one thing - a travel agent that's genuinely good at booking, a cooking agent that doesn't just pull SEO-optimised recipes, a fitness agent with his preferences, and an all-purpose one for research - plus one place to gather context that all of them pull from. His complaint about the current generation is specific and correct: juggling multiple topics in one agent chat thread is a terrible experience. He also flags the risk with the most polished consumer versions, which is that they optimise for time spent in-app.
@Ryrenz [Claude Code]
https://x.com/Ryrenz/status/2097159242411077994
Covers a mobile MCP that connects iOS and Android simulators, emulators and real devices to Claude Code and other MCP clients, and the design decision is the useful bit. It talks to the interface two ways: it prefers reading the accessibility snapshot, which gives structured element information and is far more accurate than guessing coordinates from a screenshot, and only falls back to screenshot-and-tap when it can't. So what runs is real native interaction on a real device rather than a performance in a fake environment. The pain it removes is familiar to anyone doing mobile testing - move one button in a signup flow and you re-tap the whole thing by hand on two devices, then screenshot it all. One caveat: it sends anonymous usage telemetry by default, with an environment variable to turn it off.
@BeamManP [Claude Code]
https://x.com/BeamManP/status/2097377016614101470
Released an MCP server that lets Claude Code and other MCP clients drive MMD, controlling pose, expression, camera, lighting and effect settings. His own framing is admirably deflationary - this is not "AI generates god-tier motion automatically", and he says so directly. But for the narrow overlap of people who use both agents and MMD, it turns a manual creative tool into something an agent can operate.
@lnkiai [Claude Code]
https://x.com/lnkiai/status/2097195463799967966
Makes promotional videos with a two-step handoff worth stealing: gather the assets and build the UI in Claude Code first, then say "make a video with Remotion". Doing the composition as code after the visual pieces exist is what makes the output consistent rather than a lottery.
@7uanF [Claude Code]
https://x.com/7uanF/status/2097369535686774864
Flags a repo that pulls search optimisation for AI-driven queries inside Claude Code: pass it a URL and it audits citability, AI crawlers and schema markup, then generates a client-ready PDF report. The report generation is the part that turns it from a check into something billable.
@SebastienEgo [Claude Code]
https://x.com/SebastienEgo/status/2097374510127227030
Notes Claude Code custom output styles landing and why it matters to him specifically: he likes the model but it talks a great deal, and being able to force concise, result-first answers at the system prompt level rather than asking nicely every time is the fix. It's a small feature that addresses one of the most common complaints in this feed.
@herbertyang [OpenClaw]
https://x.com/herbertyang/status/2097156529396859382
Running a Linux distribution built around AI agents on a 2019 Intel MacBook Pro and reports the thing that made it click: once Claude Code was set up, he does everything from inside it. The agent can go several levels under the hood of both the OS and the machine, which is the actual argument for an agent-native OS rather than the aesthetics.
🗣 User Voice
User Voice
Cost visibility is the loudest unmet need, and it's a tooling problem rather than a pricing one. @G_Programming lost 85% of a weekly allowance to a session whose context had silently grown to a million tokens and wants context size and per-turn cost in the status line before he presses enter, plus a prompt to compact past a threshold. @charly_0w0_ replied that you can already put a dollar figure in a custom status line and add hooks that warn on context growth - the problem being that none of it ships on by default. @ryanlpeterman, @sattyyouneed, @HeyAliux and @Seltaa_ all report burning weekly limits in days, and @Yuki0_0Maru reports 20-plus Max accounts cancelled at a single office once model routing changed how they worked.
Cross-agent handoff and shared memory came up from more directions than any other request. @i_mika_el asks the sharpest version: subagents get a fresh context window and the parent only sees the summary they return, so is anyone dumping findings to a file, or does every run re-explore the repo from zero? @QQzlans has to re-explain himself at every session. @t_hirakawa predicts encrypted session history managed per user and organisation because local-only is inconvenient. @christophrumpel's agent work is split across a dozen apps and he wants one place. @Nirmal_Utwani asks who is building the conductor for personal assistants. @mukaisan9 wants an environment where he doesn't have to hand over to each tool separately.
Agents are too verbose, and the fix people want is a per-channel one. @SergioGMN's version is the best-argued: if you build a Telegram bot, it's a chat - he wants monosyllables and one-or-two-sentence notifications, with anything longer moved to a wide screen or a phone call. His example is waiting on a blood test result: he wants "the report just arrived, everything's fine, we'll look at the details later", not a 30-page report pushed to Telegram. @SebastienEgo found the closest fix in custom output styles forcing concise, result-first answers at the system prompt level.
Trust and blast radius are now blocking adoption for people who otherwise want in. @urieli17 won't try personal agents at all because of data leakage risk, especially around his messaging apps. @XMihura installed one, agreed it works, and uninstalled it because he can't see what's behind something holding his credentials. @Greg_GL_87 runs Claude Code most of the day and still wouldn't hand it his browser unsupervised. @gt_eros had his C drive touched unprompted. @rolznz notes 80% of his poll respondents run agents in a separate machine or sandbox and asks the follow-up nobody wants to answer: the UX of doing that is bad - broken copy-paste especially for images, broken scrollbars, no voice notifications, odd hotkeys - and we all do it anyway.
Reliability of self-hosted agents is a real churn driver. @karthikabinav was excited, used it for everything, and gave up because keeping it alive became a full-time job. @lucasradaelli has a vanilla install and fixes something every week - this time the auto-updater got stuck, last week a session format migration broke. @charlesmcdowell asks his agent to update itself and it breaks every time. Against that, @asindexai had an orchestrator run a major update end to end with regression tests on a heavily customised setup, which suggests the difference is having a verification step rather than luck.
Cost visibility is the loudest unmet need, and it's a tooling problem rather than a pricing one. @G_Programming lost 85% of a weekly allowance to a session whose context had silently grown to a million tokens and wants context size and per-turn cost in the status line before he presses enter, plus a prompt to compact past a threshold. @charly_0w0_ replied that you can already put a dollar figure in a custom status line and add hooks that warn on context growth - the problem being that none of it ships on by default. @ryanlpeterman, @sattyyouneed, @HeyAliux and @Seltaa_ all report burning weekly limits in days, and @Yuki0_0Maru reports 20-plus Max accounts cancelled at a single office once model routing changed how they worked.
Cross-agent handoff and shared memory came up from more directions than any other request. @i_mika_el asks the sharpest version: subagents get a fresh context window and the parent only sees the summary they return, so is anyone dumping findings to a file, or does every run re-explore the repo from zero? @QQzlans has to re-explain himself at every session. @t_hirakawa predicts encrypted session history managed per user and organisation because local-only is inconvenient. @christophrumpel's agent work is split across a dozen apps and he wants one place. @Nirmal_Utwani asks who is building the conductor for personal assistants. @mukaisan9 wants an environment where he doesn't have to hand over to each tool separately.
Agents are too verbose, and the fix people want is a per-channel one. @SergioGMN's version is the best-argued: if you build a Telegram bot, it's a chat - he wants monosyllables and one-or-two-sentence notifications, with anything longer moved to a wide screen or a phone call. His example is waiting on a blood test result: he wants "the report just arrived, everything's fine, we'll look at the details later", not a 30-page report pushed to Telegram. @SebastienEgo found the closest fix in custom output styles forcing concise, result-first answers at the system prompt level.
Trust and blast radius are now blocking adoption for people who otherwise want in. @urieli17 won't try personal agents at all because of data leakage risk, especially around his messaging apps. @XMihura installed one, agreed it works, and uninstalled it because he can't see what's behind something holding his credentials. @Greg_GL_87 runs Claude Code most of the day and still wouldn't hand it his browser unsupervised. @gt_eros had his C drive touched unprompted. @rolznz notes 80% of his poll respondents run agents in a separate machine or sandbox and asks the follow-up nobody wants to answer: the UX of doing that is bad - broken copy-paste especially for images, broken scrollbars, no voice notifications, odd hotkeys - and we all do it anyway.
Reliability of self-hosted agents is a real churn driver. @karthikabinav was excited, used it for everything, and gave up because keeping it alive became a full-time job. @lucasradaelli has a vanilla install and fixes something every week - this time the auto-updater got stuck, last week a session format migration broke. @charlesmcdowell asks his agent to update itself and it breaks every time. Against that, @asindexai had an orchestrator run a major update end to end with regression tests on a heavily customised setup, which suggests the difference is having a verification step rather than luck.
📡 Eco Products Radar
Eco Products Radar
Codex - the constant comparison point all day, and increasingly the other half of a pair rather than a replacement; the import path from Claude Code settings was passed around repeatedly
Cursor - still the default answer for anyone who wants a GUI and a model-switching layer over the harness
OpenClaw - referenced in nearly every personal-agent thread as the thing that opened the category, now mostly discussed in the past tense by people moving to hosted alternatives
Hermes - the self-hosted alternative people migrate to when they want to stay off hosted products
MCP - the connective layer under most of today's non-coding cases; also the source of two of today's security stories
Playwright MCP - the browser layer behind the autonomous design review loop
Figma - appears on both sides: the design source Claude Code implements from, and the tool with the local-font MCP gotcha
herdr - the terminal multiplexer of choice for anyone running more than a handful of agents
Grok Bot - the hosted agent people are migrating self-hosted setups into, brain transplant and all
Omarchy - the agent-native Linux distribution showing up in the sovereign-infrastructure threads
Tailscale - the quiet dependency in every always-on Mac Mini rig
Codex - the constant comparison point all day, and increasingly the other half of a pair rather than a replacement; the import path from Claude Code settings was passed around repeatedly
Cursor - still the default answer for anyone who wants a GUI and a model-switching layer over the harness
OpenClaw - referenced in nearly every personal-agent thread as the thing that opened the category, now mostly discussed in the past tense by people moving to hosted alternatives
Hermes - the self-hosted alternative people migrate to when they want to stay off hosted products
MCP - the connective layer under most of today's non-coding cases; also the source of two of today's security stories
Playwright MCP - the browser layer behind the autonomous design review loop
Figma - appears on both sides: the design source Claude Code implements from, and the tool with the local-font MCP gotcha
herdr - the terminal multiplexer of choice for anyone running more than a handful of agents
Grok Bot - the hosted agent people are migrating self-hosted setups into, brain transplant and all
Omarchy - the agent-native Linux distribution showing up in the sovereign-infrastructure threads
Tailscale - the quiet dependency in every always-on Mac Mini rig
Comments