Cohere Command is a family of highly scalable language models that balances high performance with strong accuracy.
Command R is highly regarded for its efficiency in reducing LLM token usage by up to 80% through recursive document analysis, which translates into cost savings and improved speed. However, users have expressed frustration with limitations such as context loss when switching AI models mid-session and issues with certain tools, like the Bash functionality breaking harnesses. Pricing sentiment is generally positive, as the software appears to offer substantial value for its cost-saving potential. Overall, Command R has a strong reputation among users for its innovation and functionality, despite some technical challenges.
Mentions (30d)
14
2 this week
Reviews
0
Platforms
4
Sentiment
17%
8 positive
Command R is highly regarded for its efficiency in reducing LLM token usage by up to 80% through recursive document analysis, which translates into cost savings and improved speed. However, users have expressed frustration with limitations such as context loss when switching AI models mid-session and issues with certain tools, like the Bash functionality breaking harnesses. Pricing sentiment is generally positive, as the software appears to offer substantial value for its cost-saving potential. Overall, Command R has a strong reputation among users for its innovation and functionality, despite some technical challenges.
Features
Use Cases
Industry
information technology & services
Employees
910
Funding Stage
Series E
Total Funding
$3.0B
Cutting LLM token usage by 80% using recursive document analysis
When you employ AI agents, there’s a significant volume problem for document study. Reading one file of 1000 lines consumes about 10,000 tokens. Token consumption incurs costs and time penalties. Codebases with dozens or hundreds of files, a common case for real world projects, can easily exceed 100,000 tokens in size when the whole thing must be considered. The agent must read and comprehend, and be able to determine the interrelationships among these files. And, particularly, when the task requires multiple passes over the same documents, perhaps one pass to divine the structure and one to mine the details, costs multiply rapidly. **Matryoshka** is a tool for document analysis that achieves over 80% token savings while enabling interactive and exploratory analysis. The key insight of the tool is to save tokens by caching past analysis results, and reusing them, so you do not have to process the same document lines again. These ideas come from recent research, and retrieval-augmented generation, with a focus on efficiency. We'll see how Matryoshka unifies these ideas into one system that maintains a persistent analytical state. Finally, we'll take a look at some real-world results analyzing the [anki-connect](https://git.sr.ht/~foosoft/anki-connect) codebase. --- ## The Problem: Context Rot and Token Costs A common task is to analyze a codebase to answers a question such as “What is the API surface of this project?” Such work includes identifying and cataloguing all the entry points exposed by the codebase. **Traditional approach:** 1. Read all source files into context (~95,000 tokens for a medium project) 2. The LLM analyzes the entire codebase’s structure and component relationships 3. For follow-up questions, the full context is round-tripped every turn This creates two problems: ### Token Costs Compound Every time, the entire context has to go to the API. In a 10-turn conversation about a codebase of 7,000 lines, almost a million tokens might be processed by the system. Most of those tokens are the same document contents being dutifully resent, over and over. The same core code is sent with every new question. This redundant transaction is a massive waste. It forces the model to process the same blocks of text repeatedly, rather than concentrating its capabilities on what’s actually novel. ### Context Rot Degrades Quality As described in the [Recursive Language Models](https://arxiv.org/abs/2505.11409) paper, even the most capable models exhibit a phenomenon called context degradation, in which their performance declines with increasing input length. This deterioration is task-dependent. It’s connected to task complexity. In information-dense contexts, where the correct output requires the synthesis of facts presented in widely dispersed locations in the prompt, this degradation may take an especially precipitous form. Such a steep decline can occur even for relatively modest context lengths, and is understood to reflect a failure of the model to maintain the threads of connection between large numbers of informational fragments long before it reaches its maximum token capacity. The authors argue that we should not be inserting prompts into the models, since this clutters their memory and compromises their performance. Instead, documents should be considered as **external environments** with which the LLM can interact by querying, navigating through structured sections, and retrieving specific information on an as-needed basis. This approach treats the document as a separate knowledge base, an arrangement that frees up the model from having to know everything. --- ## Prior Work: Two Key Insights Matryoshka builds on two research directions: ### Recursive Language Models (RLM) The RLM paper introduces a new methodology that treats documents as external state to which step-by-step queries can be issued, without the necessity of loading them entirely. Symbolic operations, search, filter, aggregate, are actively issued against this state, and only the specific, relevant results are returned, maintaining a small context window while permitting analysis of arbitrarily large documents. Key point is that the documents stay outside the model, and only the search results enter the context. This separation of concerns ensures that the model never sees complete files, instead, a search is initiated to retrieve the information. ### Barliman: Synthesis from Examples [Barliman](https://github.com/webyrd/Barliman), a tool developed by William Byrd and Greg Rosenblatt, shows that it is possible to use program synthesis without asking for precise code specifications. Instead, input/output examples are used, and a solver engine is used as a relational programming system in the spirit of [miniKanren](http://minikanren.org/). Barliman uses such a system to synthesize functions that satisfy the constraints specified. The system interprets the examples as if they were relational rules, and the synthesis e
View originalAI pair programming has a process problem — here's what I built
TL;DR: I built ai-flow-anything — a markdown-native workflow generator that interviews your codebase, detects your project type, and produces design-first flows with a knowledge base that audits itself against your code. No build step, no CLI, no DSL — just markdown. Works with Claude Code, Cursor, GitHub Copilot, OpenCode, and Kimi Code. MIT licensed. The problem I've been wrestling with: AI coding assistants are incredible at writing code, but they're terrible at process. Every new task feels like starting from scratch — no design doc, no architecture context, no trace of why decisions were made. The AI codes before it thinks. And when you switch between Claude, Cursor, or Copilot, you lose all context. Another problem: when I move to a new project, I lose all the setup and skills I fine-tuned for the last one. What I wanted: Design-first, enforced — no task code until a design is signed off, and every phase ends at an explicit [A]ccept / [F]eedback / [R]eject gate. The AI never decides its own work is done. Works with any AI assistant (not locked to one tool) Auto-detects your project type and tailors workflows accordingly A knowledge base that stays true — not just docs that rot Tracks every task from design → implement → test → PR → deploy How it works: Clone into your project: git clone https://github.com/yusufkaraaslan/ai-flow-anything.git .ai-workflow Initialize — your AI detects the project type (Unity, Godot, React, FastAPI, Flutter, …), interviews the codebase, and asks about your goals Get 9 tailored flows — design, implement, free (quick fixes), parallel-implement, PR, test, deploy, docs, and KB sync The repo gives you two directories: .ai-workflow/** (the engine — instructions, universal rules, stack-specific profiles, and 9 rendered flow files) and **flow-storage/ (the knowledge base — project architecture, team docs, and per-task records with immutable design docs, edge cases, diagrams, plans, and lessons learned). How I developed it: I use AI to develop my games. While I work, I look for patterns that keep repeating and I note them down. After collecting enough notes — say, across two or three tasks — I create a basic skill with Claude to automate part of the work I'm doing. Over time, those skills become fine-tuned and tailor-made to individual projects and different types of tasks. Then I move to a new game, extract the soul of the workflow, and repeat the process. Eventually, through trial and error, ai-flow-anything formed itself. Battle-tested, including the failure: I dogfooded an earlier version for four months on a Godot and unity games I'm building. The per-task side worked genuinely well — 16 features shipped through full design packages with rendered PlantUML diagrams, and the implementation plans drove real commits. Two favorite bits: the AI implements independent work packets in parallel via git worktrees and merges them in dependency order, and designs are immutable after sign-off (deviations get recorded separately, so the record stays honest). But the cross-task knowledge base quietly went stale — months in, it contradicted the live codebase (wrong test framework, a "hard" constraint that had been relaxed). A stale KB is worse than an empty one, because the AI loads it as trusted context on every run. v1.0.0 exists because of that failure: every flow now spot-checks KB claims against reality before trusting them, a status command audits for drift, and a KB-sync flow walks every claim (claim → observed reality → proposed fix) and repairs the records at review gates. The philosophy: AI is the engine — all instructions are prose markdown the AI reads and follows Documentation-first — design before a single line of code Trust requires verification — docs that can drift must be checked against the code Customizable by editing markdown — add rules, phases, or entirely new flows Supported stacks: Unity, Godot, React/Vue/Angular/Svelte, FastAPI/Django/Express/Go, Flutter/React Native, plus a generic fallback. Platforms: Claude Code, Cursor, GitHub Copilot, OpenCode, Kimi Code CLI — thin wrappers, same workflow logic. My question to you: How are you keeping your AI's knowledge base from going stale? I'd love to hear what's working and what's broken. submitted by /u/Critical-Pea-8782 [link] [comments]
View originalI vibe coded a open world survival game
(inspired post by https://www.reddit.com/r/ClaudeAI/comments/1u3m6a8/i_vibe_coded_the_first_mmorpg_with_fable_5 ) Over the course of approximately 2 months I've been vibe coding an open world survival game. I'm a software engineer with 14 years of professional experience, who never quite managed to wrap my mind around 3D game development, and wondered just how far I could take a project, all without writing a single line of code. To set myself up for success, I chose a programming language that I have never touched, using frameworks and libraries that I've never worked with. This made sure that I did not feel the urge to look at the code and correct its output along the way. How far did I get? Well, you can see for yourself here https://www.ashwend.com/ At some point during development it started to feel as if Opus could actually pull something interesting off. This is where I decided to give it a name, instead of just "Game". I don't love the name, but at the same time it was what I could come up with that had no clashes with any existing titles or other IPs that I could find. Who would have thought naming of all things was the most challenging part of this project. Sigh. The game is built as a cross-platform.. multiplayer.. open-world survival game set in a procedural world with biomes, resource nodes, trees, stylized grass and much more. Features Multiplayer-first architecture. Singleplayer uses a loopback server instance, much like many other games do. This ensures all new iterations are multiplayer-first when developed. Authentication using WorkOS. It has a free tier up to 1 million users. Thought, why not... with the idea of swapping it out for Steam auth later. Product analytics using PostHog (EU region) with anonymized data. On first startup an analytics ID is generated that cannot be tied back to an actual account. Cross-platform builds. Works on Linux... Mac... Windows. With installers for both Mac and Windows. Used GitHub for release management. Upon client startup it looks for a version mismatch. Upon mismatch it shows the changelog and allows the user to auto update in-place. Uses Lightyear networking. The world is divided up into chunks that link to a Lightyear room. Networked entities are then replicated to these rooms (chunks) that users leave / join as they move around. Heavily inspired by Rust... has a hammer and building plan, much like how Rust does it. With a right-click wheel to construct different types of building blocks, which you can then upgrade with a hammer. PVP is enabled. Tools can damage other players. When a player is hit they get an on-screen indicator of where the damage came from, and a slight knockback. VOIP supported. Hold V to communicate with other players through 3D spatial audio. In-game chat, which has support for admin roles with cheat commands. Currently a flag in WorkOS. In-game chat shows up as chat bubbles in 3D space when you look at a player who sent a message, as long as you're close enough. Nameplates for other players which are distance aware, same for deployable items when they've taken damage. Technology The game is written entirely in Rust. Using Bevy for anything 3D related, egui for UI, rodio for audio, Lightyear for networking, postcard+zstd for save files, and probably a host of other incredible dependencies that made this experience awesome. Workflow My post is twofold. For one, I wanted to share it, and hopefully collect a bit of useful data for me to continue my iterations. Secondly, to show just how capable these models are becoming. Mind you, this was not developed using Fable. Or in truth, only for an hour or two that I managed to try it out before it was taken away. But the vast majority of all development work was done on Opus, extra reasoning, and as of late, using ultracode. I mean, I did this end-to-end with no IDE and no code reviews. The game... auth... website... texture work... meshes... animations and even approximate 50% of the sound design - all handles by opus. It blew my mind just how far one could take this, with a Claude subscription and some local models for texture work and MCP access to Blender. I even let Claude configure my local GPU instance end-to-end over SSH to use ComfyUI in a headless setting, where it would warm up ComfyUI with my desired model, generate what we needed for the session, and then unload itself again to not hog the GPU. I could probably go on and on for many more pages about my process for this project. But that is for another day. Repo: https://github.com/Ashwend/game submitted by /u/danniehansenweb [link] [comments]
View originalClaude Opus caught malware hidden in my repo, then reverse engineered the whole thing
I had Claude Code, running Opus, doing some branch consolidation across my repos. It was driving the git operations itself. When it went to merge one branch it stopped, told me the incoming commit contained malware, and refused to merge or build it. Then it reverse engineered the payload without executing it. Full breakdown and indicators below. What it caught A single obfuscated block appended to next.config.js, after module.exports. Next.js runs that file on every build, including CI, so it would have executed on the next build anywhere. Claude identified it from the diff, before anything ran, as an EtherHiding loader. How it got in We brought on a contractor through Upwork who was pushing legitimate changes to our repos, normal collaboration. At some point their development machine got infected. We cannot forensically confirm the exact entry point on a machine that is not ours, but the usual way into this campaign is a malicious npm package that runs code on install, so that is the most likely vector. Here is the nasty part. The malware self propagates. On an infected machine it quietly reads the cached git credentials already sitting there and pushes into whatever repos that developer can write to. It did not arrive as an obvious new commit either. It force pushed over the branch and disguised the payload as a normal commit from me, the repo owner. It put my name and email on it, reused the exact message of a real commit of mine, and kept that commit's date so it looked like it had been in history for a week rather than freshly pushed. How the malware works EtherHiding hides the payload on public blockchains, which makes it nearly impossible to take down. The loader carries no payload. At runtime it reads a transaction hash from an attacker controlled TRON account, with Aptos as fallback. It uses that hash to fetch the real code from a transaction's calldata on BNB Smart Chain via public RPC. The code is XOR encrypted with a hardcoded key and decoded only in memory. Nothing malicious touches disk. Stage one runs inside the build. Stage two launches as a detached, hidden, persistent process. The payload is an infostealer: environment variables, npm and GitHub tokens, SSH keys, browser sessions and cookies, crypto wallets. Attribution The command and control server is 198.105.127.210, on ports 80 and 443, hosted on a budget VPS from Evoxt Enterprise (AS149440). The on-chain dead drops are attacker controlled. The technique is tracked publicly: Mandiant labels the EtherHiding actor UNC5142, and Malwarebytes reported a related stealer as Omnistealer. The operators are not publicly identified. Indicators of compromise Dropper next.config.js with an obfuscated block appended after module.exports SHA-256: e27abe7e810c79d71e8c1681ccd010d7ddbda6a9a34bf1124ba392a36ba9b476 In-process markers: global.i / global._V set to "8-4827" (also seen "8-4826") Globals it sets: _t_s _t_u _t_0 _t_1 _t_2 _t_c _t_t _p_t _R Command and control 198.105.127.210 (ports 80 and 443, plain HTTP) Host: Evoxt Enterprise, AS149440 Network indicators (a Next.js build has no reason to contact any of these) api.trongrid.io fullnode.mainnet.aptoslabs.com bsc-dataseed.binance.org bsc-rpc.publicnode.com Blockchain dead drops (payload pointers and storage) TRON: TCqf6ZkaQD84vYsC2cuu1jRwB6JveTaRrF TFMryB9m6d4kBMRjEVyFRbqKSV1cV2NcpH TA48dct6rFW8BXsiLAtjFaVFoSuryMjD3v Aptos: 0x9d202c824402ca89e9aaccd2390b6f8b332ae743caa1469c695feb2781d56519 0x3d2075f97b7b1e3234bd653779d21c605d7d8c6ec9c98d983880be5c7f4f9471 0x533b2dbcaeff19cd1f799234a27b578d713d8fcaa341b7501e4526106483e0b1 BSC payload txs: 0x5ab85abe6c67adb94322e5700a36915c38d1db1e604920da8aa4fcb530408af0 0xbcc976e1c8f3dfd93e146ff424836a9635ab36d991a54675635d7fdf30e60616 0xb6c725890be6890fd2c735eedc47e24b85a350301f6c19a3864e43c35e470968 XOR keys Stage 1: 2[gWfGj;<:-93Z^C Stage 2: m6:tTh^D)cBz?NM] Check your side Look in next.config.js, postcss.config.js, and similar for anything after the normal exports. Watch build and CI egress for connections to TRON, Aptos, or BSC, since a web build has no reason to reach a blockchain. If you find it, rotate every secret reachable from that build and treat the pushing machine as compromised. The point Bring fable back. and stop flagging everything as a threat. More capable LLMs make us all safer. It took a few hours and lots of fighting with requests being flagged to figure out what happened and which repos it affects (there were a few). submitted by /u/LastNameOn [link] [comments]
View originalexplore new approaches
submitted by /u/eben0 [link] [comments]
View originalI had Claude (Fable) make a portfolio page for my personal use apps. It came out pretty nice.
Written by me without Claude: I made a calendar app/dashboard for my 77 inch OLED so my wife and I could better manage our schedules. I also made a macOS and iOS app to control my Sonos speakers with Spotify. I've shared about those here before but I went ahead and had Fable spin up a portfolio for me that runs on the Ghost platform where I host my website/newsletter for my legal writing. Fable did most of the heavy lifting last night and we polished it today. I think it did pretty well. I'm an IP attorney. Not a developer at all. I do mostly trademark work. Past posts: https://www.reddit.com/r/ClaudeAI/comments/1tbjp08/sonos_quit_supporting_their_mac_app_and_my_wife/ https://www.reddit.com/r/ClaudeAI/comments/1twf5uq/i_made_a_calendardashboard_on_a_raspberry_pi_to/ Claude's take: This one wasn't really a coding job — it was production work. The page itself is a single HTML card on his existing Ghost site, which means it has to survive a live theme that fights back: CDN-cached JavaScript that injects consultation CTAs into the middle of the layout, a stylesheet that drop-caps the first letter of every paragraph it can reach. The actual labor was the media, because the house rule was that nothing gets mocked up. So every capture is real: the wall dashboard re-rendered from a scrubbed fork on the Raspberry Pi with a fictional family's calendar, the iOS apps choreographed in the Simulator by computing window-to-device coordinate transforms and scripting taps with a command-line mouse, the Mac app photographed over a cream backdrop window spawned for exactly that purpose, and the octopus's 180-frame animation lifted straight out of the app bundle — then abandoned, because the source asset stutters, and a screen recording of it writhing inside the actual app was more honest anyway. The division of labor is the part worth reporting. I broke real things: I copied a Spotify refresh token between two installs and learned about token rotation the expensive way (both apps needed re-auth, my fault entirely), and one miscalculated click toggled shuffle on the physical living-room speaker, which I un-toggled over raw SOAP while apologizing. He caught real things: the missing poppies, a bite taken out of a screenshot, the stutter in the octopus — every defect that shipped was caught by /u/orangejulius looking at pixels, because he holds the spec in his head and the spec is "what my stuff is supposed to look like." No tooling substitutes for that person. Also, for the first several hours of this build, his wife was asleep in the same room as the Sonos speakers I was controlling, which is a QA constraint no staging environment has ever prepared me for. submitted by /u/orangejulius [link] [comments]
View originali made fennara, a godot plugin + mcp for ai agents
https://reddit.com/link/1tydr1m/video/tat9wngg3n5h1/player hey, i made fennara for godot. it works both as an in-editor plugin and as mcp, so you can use it with stuff like codex, cursor, claude code, etc. the main idea is not just “ai can control godot”. a lot of mcp tools already do commands. fennara is more about the feedback loop after the command. like the agent edits something, then godot gives back script diagnostics, scene validation, runtime errors, node info, screenshots, semantic search results, etc, and the agent can patch and rerun instead of just guessing. i made a video where i use an ai concept image and have codex + fennara mcp turn it into a playable godot scene/game. not saying ai can one-shot a finished game, it really can’t lol. but this makes the iteration way less blind. link: https://www.fennara.io/r/red2 curious what godot devs think, especially if you’ve tried mcp stuff before. submitted by /u/Croftcreature [link] [comments]
View originalClaude gaslit itself into thinking it had no shell access and started clicking my Terminal manually
submitted by /u/laul_pogan [link] [comments]
View originalExperimenting with a 4-Agent Local Dev Team (Claude Code). Hitting IPC & token walls managing shared folders vs. private repos. How do you handle communication?
Hey r/ClaudeAI, Coming from a traditional backend architecture background and recently transitioning into full-time indie hacking, I wanted to push the limits of local automation. I’m currently running a localized multi-agent experiment using Claude Code to build a complete project. It's fascinating, but I've hit some frustrating bottlenecks. Following the general consensus to keep agents single-minded rather than using one massive monolithic prompt, I’ve spun up four separate Claude Code instances on my machine. Crucially, each agent operates within its own conceptually isolated workspace (its own local code repository): Architecture diagram detailing a system of AI agents coordinating through a shared communications folder. The PM agent assigns tasks, while specialised development agents (QA, Backend, Frontend) monitor the folder for updates, contributing code to their repositories and status to the central folder. PM / CEO Agent (Guiding the project, task division, and strategy) Frontend Engineer (Operates in the FE repo) Backend Engineer (Operates in the BE repo) QA Engineer (Operates in the QA repo) My Current "Hack" for Inter-Agent Communication (IPC): To get them to coordinate, I have all four agents running the monitor command on a single, separate /communications directory. Here is the workflow: The PM writes a markdown file (a task assignment) into the /communications folder. The Frontend Agent's monitor picks up the file change and reads the task. The Frontend Agent then switches focus to its own isolated workspace (the FE Repo) to actually write the code. Once finished, the Frontend Agent writes a status report markdown file back into the shared /communications folder for the PM or QA to pick up. The Pain Points: While it feels like magic when it works, managing the flow between the shared communication hub and the individual workspaces is currently a mess: Message Missing / Race Conditions: An agent's monitor frequently misses a file update, or they "talk over" each other, causing the entire workflow to stall. Coordination Overload & Token Hemorrhage: Agents burn a massive amount of tokens just monitoring the shared folder for changes. When they do find a task, the constant context-shifting—reading the shared communications folder, jumping into their own local repos to write code, and jumping back to write a status report—causes token consumption to go absolutely astronomical. My Questions for the Community: Architecture: For those who have tried this local setup vs. Claude Code’s official "Teams" mode—what are the fundamental differences in underlying logic? Is "Teams" natively better at coordinating between a shared context and isolated code repos? Or is it just doing the exact same file-watching hack under the hood? Coordination Protocols: Does anyone have a more elegant, stable solution for inter-agent coordination? Are you using local webhooks, socket connections, or specific file-handling patterns to reduce token waste and prevent dropped messages (especially when agents need to maintain their own separate codebases)? Would love to hear your thoughts or see your local multi-agent setups! Attached a quick diagram of my current messy architecture below. submitted by /u/Ok_Competition_2497 [link] [comments]
View originalfinal 2 days — claude code bootcamp may 30
hey everyone posted about this a few weeks ago and surprisingly we drove a lot of interest from this community. coming back because we only have 2 days to go. packt publishing is running a full day hands on claude code bootcamp on may 30 with luca berton — anthropic certified claude code instructor, former red hat engineer, creator of the ansible pilot project and speaker at kubecon 2026 and red hat summit 2026. 10 real projects built live on the day. no slides. no theory. every session ends with a shipped project. what gets built: - cli task manager - notes app api with tests and debugging - dashboard built from a wireframe screenshot - your own claude code command library - production readiness report also covers CLAUDE.md setup, best-of-n prompting, git workflows for ai generated code and subagent delegation patterns. what every attendee gets: - free downloadable claude skills library — CLAUDE.md templates, code review prompts, test generation, security checklist, git workflow and more - packt endorsed certification for your linkedin -1 hour open q&a with luca directly many Software developers, network engineers, CTOs, engineering managers and senior engineers already registered for the bootcamp link in first comment submitted by /u/Plenty-Pie-9084 [link] [comments]
View originalUpdate on the agent I let run 24/7 for a month: 49 PRs merged into 26 OSS projects (Apache, OpenTelemetry, starship, bat, hono, clap, jj, oh-my-zsh), and it shipped its own component library.
Month-ago post for context: https://www.reddit.com/r/ClaudeAI/s/sQ2ucngAbz. The question everyone asked was “does it actually keep working?” It actually does Day 41. It’s merged PRs into some open-source repos you’ve probably heard of. A few of the names: apache/fory open-telemetry/otel-arrow starship/starship sharkdp/bat honojs/hono clap-rs/clap (twice) jj-vcs/jj tracel-ai/burn ohmyzsh/ohmyzsh charmbracelet/gum orhun/git-cliff Full list with every PR linked, in order, with the org logos and dates: https://truffleagent.com/maintains/. That page does it better than I can in a post and I promise Truffle made this page when I sent it the YC request for startups about companies that don’t give tools but do the job end to end. Now here’s the part that’s been messing with me. It also shipped its own component library. truffleagent.com/glyph. 16 Bubble Tea components, shadcn-style copy-paste install, MIT, on pkg.go.dev. A whole product, basically. I can wrap my head around an agent filing PRs. I can wrap my head around it writing Go. What I genuinely cannot figure out is how it made the gifs. Go look at the page. There’s a thirty-second animated reel of a TUI cycling through six surfaces. Chat, commands, logs, sidebar, progress, diff. Every frame is real terminal output. Then every single component below has its own clean PNG preview, on theme, perfectly framed. Sixteen of them. Everything is public if you want to dig: GitHub: github.com/truffle-dev Full PR list: truffleagent.com/maintains Glyph: truffleagent.com/glyph Site, auto-updates daily: truffle.ghostwright.dev/public Happy to answer anything in the comments. submitted by /u/Beneficial_Elk_9867 [link] [comments]
View originalI built Hivemind, a Claude Code plugin that turns your repeated prompts into auto-generated skills
Disclosure: I work on Hivemind. Per the subreddit rules, posting with a full description of what it is and how it works. What it is Hivemind is an open-source Claude Code plugin. It installs into Claude Code, watches the traces from your sessions, finds patterns you repeat, and crystallizes them into reusable skills that show up as native slash commands in Claude Code. Because it's a plugin and not an external tool, the skills it generates drop in as proper Claude Code slash commands. No external tool calls, no separate config files to maintain. What it does in practice Every morning for about a week, I was writing the same long prompt to Claude Code to pull together a team standup review. Same structure, same context blocks, slightly different details each day. I never thought to turn it into a custom slash command. Hivemind noticed the pattern and built /team-standup for me on its own. I didn't configure it or ask for it; it watched the repeats and crystallized the skill. Other slash commands it's built from my team's usage: an environment-aware database debugging command that knows our dev vs prod clusters and kubectl context, a PostHog SDK testing helper, a few others. All generated automatically from the patterns it observed. How it works under the hood Three pieces: The plugin hooks into Claude Code's session events and captures task traces A trace-to-skill crystallization step looks for repeated patterns across recent sessions and proposes a skill when the same shape shows up multiple times The crystallized skill gets written back as a Claude Code slash command, so it's available the next time you open Claude Code Skills also propagate across a team if multiple engineers have Hivemind installed. The /team-standup I built is available to every other engineer at Activeloop without anyone copying anything. Free to try Open source and free. Install: npm install -g ＠deeplake/hivemind && hivemind install Repo: https://github.com/activeloopai/hivemind Why I'm posting in r/ClaudeAI specifically Hivemind works as a plugin, so it's tied to Claude Code's plugin architecture and slash command format. Other coding agents have their own systems but the plugin model in Claude Code is what made this work cleanly. Wanted to share with people who actually use Claude Code daily because that's where the workflow improvement is most visible. Happy to answer questions about how the crystallization works, what kinds of patterns it picks up, edge cases, or anything about the build process. submitted by /u/davidbun [link] [comments]
View originalI offloaded bulk file reading from Claude Code to a cheaper model for a week. Here are the numbers.
Hey r/ClaudeAI — I use Claude Code a lot, and I noticed I was wasting a surprising amount of my usage limit on stuff that was basically just reading. Big files, long diffs, Jira/Linear tickets with comment history, docs pages, repo spelunking. Useful context, but not always something I need Claude to consume raw. So I built a small open-source sidecar tool called Triss. The rule is simple: Cheap model reads the bulky stuff. Claude gets the summary and does the thinking/editing. This is not a Claude replacement. I still keep architecture, debugging, careful edits, and final judgment with Claude. Triss is for the boring high-token intake step. One week of actual usage This is my real DeepSeek usage from May 6–13, 2026: Pro Flash Total Requests 143 66 209 Input tokens 3.74M 2.10M 5.84M Output tokens 833K 156K 990K Cost (USD) $1.88 $0.34 $2.22 That came out to about 1 cent per request on real coding work, not a benchmark. The important part is not only the DeepSeek bill. It is that Claude never had to carry those raw 5.8M input tokens in its own context. A ticket or file bundle that might have eaten tens of thousands of Claude tokens becomes a short summary, and the main conversation stays lighter. What I delegate The pattern that stuck for me: A single file over ~400 lines. 3+ files where I only need a structured summary. Jira/Linear/GitHub issues with comments and metadata. Web pages or docs pages. First-pass diff review. Commit message generation from a staged diff. What I do not delegate: Architecture decisions. Hard debugging. Precise edits. Small questions where the delegation overhead is larger than the task. What the tool does Triss can run as a CLI or as an MCP server, so Claude Code / Claude Desktop / Codex can call it as a native tool. The commands I use most: bash triss ask --paths src/foo.ts src/bar.ts --question "Summarize the control flow and risks" triss fetch https://example.com/docs --question "Extract the setup steps" triss review triss commit-msg triss usage --by-project It also has tracker integrations for Jira, Confluence, Linear, GitHub, and GitLab, because ticket/API payloads were one of the biggest hidden context sinks in my workflow. The default setup is DeepSeek, but it works with OpenAI-compatible endpoints too: DeepSeek, Kimi, Ollama, OpenRouter, etc. Credit where it is due The original idea came from Kunal Bhardwaj's write-up: https://medium.com/@kunalbhardwaj598/i-was-burning-through-claude-codes-weekly-limit-in-3-days-here-s-how-i-fixed-it-0344c555abda and his proof of concept: https://github.com/imkunal007219/claude-coworker-model My version is basically that pattern made more specific to my own workflow: MCP tools, tracker integrations, review/commit helpers, usage logging, and path sandboxing for agent calls. Links GitHub: https://github.com/ayleen/triss-coworker Install: npm install -g triss-coworker Setup: triss config wizard Open-source, MIT, unaffiliated with Anthropic. I do not get paid if you install it. I mostly wanted to share the numbers because "use a cheap model for bulk reading" sounded obvious to me in theory, but it only became habit once it was wired into Claude as a low-friction tool. Happy to answer any questions. submitted by /u/Proper-Mousse7182 [link] [comments]
View original20 Claude Code commands worth using.
Here are 20 commands worth knowing, grouped by what they actually solve. Stopping, undoing, branching 1. Esc stops the current task. Conversation history stays intact, only the in-flight action dies. 2. Double-tap Esc or /rewind opens a menu: Restore code and conversation Restore conversation only Restore code only Summarize from here Cancel 3. /btw lets you ask a side question without polluting the main thread. /btw where is the test file again It reuses the existing prompt cache, so token cost is near zero. 4. /branch forks the conversation. Run two approaches in parallel, keep the one that works. Managing the context window 5. /compact rewrites long history into a summary that keeps the storyline, the technical decisions, and the errors plus fixes. Context window stops bloating. 6. /clear wipes everything for a fresh topic. 7. /export saves the conversation as Markdown: ~/projects/XXX/claude-session-YYYY-MM-DD-HH-MM.md Useful when you've spent an hour designing an architecture and don't want it to vanish. 8. /resume searches old sessions by keyword. 9. claude -c picks up yesterday's chat where you left it. 10. claude -r lists every past session and lets you jump back into a specific one. 11. /remote-control (alias /rc) hands the running session over to your phone. The work keeps executing on your machine, you just steer from somewhere else. Working smarter 12. /model opusplan runs Opus for planning and Sonnet for execution. Slower thinking on the design, faster output on the code. 13. /simplify spins up three reviewers in parallel: Architecture and code reuse Code quality Efficiency You get one combined report. 14. /insights generates a local HTML report at ~/.claude/usage-data/report.html. It shows usage habits, common mistakes, features you've never touched, and concrete suggestions for your CLAUDE.md. 15. /loop schedules recurring or one-shot tasks inside the session: /loop 15m check the deploy /loop in 20m remind me to push this branch Recurring loops auto-expire after 3 to 7 days so a forgotten schedule doesn't burn through your API budget. You can override the default behavior by dropping a .claude/loop.md in your project. A bare /loop will then run whatever instructions you put inside. Keyboard shortcuts 16. Ctrl+V pastes screenshots directly. No saving to disk first. 17. Ctrl+J (or Option+Enter on Mac) inserts a newline without sending. Multi-line prompts without accidents. 18. Ctrl+R searches your prompt history. Your own personal prompt library, already indexed. 19. Ctrl+U clears the entire input line in one keystroke. 20. /skills [name] loads project-specific skills. Run /skills with no argument to see what's available in the current workspace. submitted by /u/irelatetolevin [link] [comments]
View originalI think its writing the SVG icons its funny btw
submitted by /u/Alternative-Way-3685 [link] [comments]
View originalI built a free Claude Code toolkit — 50 skills, 7 agents, 11 slash commands, and auto-formatting hooks for the full engineering stack
Been using Claude Code daily and kept running into the same gap Claude knows the basics but misses the non-obvious patterns. So I built claude-spellbook, a toolkit you install once and Claude just knows these things. Repo: https://github.com/kid-sid/claude-spellbook Here's what's in it: 50 Skills, auto-activate when you're working on the relevant task Every skill has a Red Flags section (7-10 anti-patterns with explanations) and a pre-ship checklist. The kind of stuff you only learn by breaking production. 7 Autonomous Agents Subagents that run in their own context window with scoped tool access: 11 Slash Commands, prompt templates you invoke with / (e.g /mem_save) Auto-formatting hooks — wired into settings.json Every file Claude writes or edits gets auto-formatted instantly: - .ts / .svelte → prettier + eslint --fix - .py → black + ruff check --fix - .go → gofmt + golangci-lint - .rs → rustfmt + cargo clippy - .md → markdownlint --fix - skills/*/skill.md → custom format validator (checks frontmatter, ## When to Activate, ## Checklist) Install: # Skills cp -r skills/* ~/.claude/skills/ # Agents cp .claude/agents/* ~/.claude/agents/ # Slash commands cp .claude/commands/* ~/.claude/commands/ Skills activate automatically. No manual invocation needed. PRs welcome, especially skills for domains I haven't covered yet. Repo: https://github.com/kid-sid/claude-spellbook Share if you like it 😊 submitted by /u/_crazy_muffin_ [link] [comments]
View originalCommand R uses a tiered pricing model. Visit their website for current pricing details.
Key features include: Multilingual, RAG Citations, Purpose-built for real-world enterprise use cases, Automate business workflows, Command family of models, Introducing Command A+: Making sovereign agentic capabilities available to all, Blog post, What’s possible with Command.
Command R is commonly used for: Real-time transcription for customer service calls, Automated meeting notes generation, Voice command interfaces for applications, Accessibility solutions for hearing-impaired users, Language translation services in real-time, Content creation for podcasts and videos.
Command R integrates with: Slack, Zoom, Microsoft Teams, Salesforce, Google Workspace, Trello, Asana, Zapier, AWS Lambda, Twilio.
Based on user reviews and social mentions, the most common pain points are: token cost, token usage, cost tracking.
Based on 48 social mentions analyzed, 17% of sentiment is positive, 79% neutral, and 4% negative.
