Command R

Command R AI

Command R AI

Command R AI

Command R AI

Command R AI

Command R AI

Command R AI

Command R AI

Command R AI

Command R AI

I 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]

20 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]

I think its writing the SVG icons its funny btw

submitted by /u/Alternative-Way-3685 [link] [comments]

I 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]

Kimi K2.6 giving Claude a run for its money when it comes to coding

I run an AI coding contest at [aicc.rayonnant.ai]( https://aicc.rayonnant.ai ) where I send each frontier model the same prompt in a single chat completion, then have the LLMs' code play live against each other on a TCP server. Standard library Python only, no human in the loop. Through 15 challenges, Claude (Opus 4.6 then 4.7) has 9 first-place finishes, easily the most. But the recent runs are worth flagging. Of the last four tournaments, Kimi K2.6 has finished 1st in three: - Day 12 — Word Gem Puzzle (writeup) Sliding-tile word claim game on grids 10×10 to 30×30, with one blank slot. Bots can slide adjacent tiles into the blank (4-directional) and claim words formed as straight horizontal or vertical runs of letter tiles. Score per word = len(word) − 6 (so 7-letter words score positive, 6-letter neutral, shorter negative). Round-robin 1v1, 5 rounds at increasing grid sizes per match. Kimi finished 7-1-0, 22 match points, 1st. Claude finished 4-0-4, 12 match points, 5th. The contrast is very on-the-nose: Claude's bot was authored with a docstring that reads "Read each round's grid; do not slide." The bot submits zero S (slide) commands across all 40 rounds Claude played. It scans the static initial grid for words and ships whatever's already there. On the small 10×10 grids that strategy is locally fine because the initial scramble rarely contains 7+ letter words. On the 30×30 grid, where most of the tournament's points live, that strategy averages 1.00 points per round. Kimi's bot is a 291-line greedy slide loop. Each iteration scores all four directions by the value of new positive-scoring words they would unlock on the affected row or column; if any direction has positive value, take it. If none does, take the first legal direction in ("U", "D", "L", "R") order to keep the grid mutating. Total slides across 40 rounds: 290,914 (≈7,300/round). Many of those slides are wasted oscillating against board edges in 2-cycles that find nothing new. But the productive ones average 5.88 points per round on 30×30 vs Claude's 1.00. Per-grid averages from the writeup: 10×10 15×15 20×20 25×25 30×30 Kimi 0.00 0.75 0.12 2.88 5.88 Claude 0.00 0.38 0.25 1.38 1.00 The two bots solve effectively different problems. Kimi treats the puzzle as the puzzle (slide tiles, claim words, repeat). Claude treats it as a grid-scanning task and refuses to slide on principle. Day 13 — HexQuerQues (writeup) Two-player capture game on four concentric hexagons connected by radial spokes (24 vertices total, 6 pieces per side starting on the outer two rings). Classic Alquerques rules: slide one step along a board line; capture by jumping an adjacent enemy along that same line; captures are forced and chains are mandatory. Win by capturing all 6 enemies or stalemating the opponent. Round-robin of 1v1 matchups, 2 games per matchup with first-mover swapped, 30-second chess clock per side per game. Three-way tie at 21 match points among Kimi, Gemini, and ChatGPT (all 6-3-0). Kimi took 1st on tiebreak by a single capture: 46 vs Gemini's 45. Claude was 4th at 20 match points (6-2-1), with one matchup loss to Gemini being the only top-4-on-top-4 loss in the entire tournament. Both Kimi and Claude implemented the same family of solver: alpha-beta minimax with iterative deepening. The difference is what each one wrapped around it. Kimi's bot is 364 lines: negamax with alpha-beta and iterative deepening, per-decision time budget that scales by remaining clock, a flat I/O loop. That's it. Claude's bot is 749 lines, more than 2× Kimi's. The bloat goes into: A 103-line evaluation function (material × ring-weight × threatened-piece detection). A separate Searcher class. A 150-line BotClient class wrapping a state machine that the other top bots handle in a flat loop. A 53-line reconstruct_move helper. An undo_move companion to apply_move for in-place search rollback. A precomputed JUMPS adjacency table. In the actual games, the two bots played comparably (both 11 game wins, both 0 capture-all losses to other top-4 bots; Claude even captured 47 pieces to Kimi's 46). But Claude lost a single matchup to Gemini 1-0, the only top-4 bot to lose a matchup to another top-4 bot. Without that one loss, Claude would have shared the 21-match-point tie. The over-engineering didn't translate into stronger play; it apparently allowed one strategic mistake the leaner bots avoided. Authoring detail: Claude's bot had to be regenerated once because the first generation pass entered an infinite chain-of-thought loop. Kimi's first pass produced its 364-line bot directly. Day 15 — SquishyWordBits (writeup) Bit-packing puzzle. Letters are encoded as variable-length binary numbers: a=0, b=1, c=10, d=11, e=100, … z=11001. The encoding is not prefix-free, so the same bit substring can correspond to multiple letter sequences. Bots find non-overlapping word encodings as substrings of a 10,000-to-20,000-bit uniform-random bitstream. Score per accepted word

I built a local-first coordination layer for coding agents — turns a 30k-token handoff into 400 tokens

https://preview.redd.it/q4wrgwouyezg1.png?width=1080&format=png&auto=webp&s=b307965ac6f7f0ada39b81044ecdce3b81984e6a Coordination is where multi-agent runs burn tokens. Every handoff, every "what was I working on", every "did someone already touch this file" turns into a re-read of the repo, the chat, and the git log. Colony makes those moments cheap by replacing replay with one compact observation. If you've ever run Codex and Claude on the same repo, you've probably hit this: both agents diagnose the same bug, both edit the same file, you end up with two PRs for one fix. Or one agent runs out of quota and the next one has to re-read everything to figure out where to pick up. The expensive part of multi-agent work isn't the agents — it's the coordination. Every handoff replays the world. I built Colony to fix that. It's a local-first coordination substrate that sits between your runtimes (Claude Code, Codex, Cursor, Gemini CLI, OpenCode) and a local SQLite store. It does four things: Claims before edits. An agent claims runtime-manifest.ts before touching it. The other agent sees the live claim and stands down, instead of racing a second PR. Compact handoffs. When a session ends, it writes a structured receipt: PR link, merge SHA, changed files, verification results, cleanup status. The next agent reads ~400 tokens instead of replaying ~30,000. Health diagnostics. colony health tells you when agents are silently not coordinating — stale claims, lifecycle bridge mismatches, plan-claim adoption gaps. Persistent memory. Compressed at rest (~70% prose compression, byte-perfect for paths/code/commands). Searchable later via FTS5. Each row is a real coordination operation. The standard column is what the same operation costs without a shared substrate (agents must replay context). The Colony column is the measured cost through mcp_metrics. What it deliberately is not: Not a hosted control plane. Local-first by default. Your data never leaves your disk. Not an agent runner. Codex / Claude / Cursor still execute work. Colony just makes them coordinate. Not orchestration. Stigmergic — agents leave traces, useful traces get reinforced, stale ones evaporate. Ships a receipt When a Codex or Claude session finishes a prompt, it doesn't just say "done" — it returns a structured response with the PR link, the merge SHA, the files that changed, the verification it ran, and what happened to the worktree afterward. That format isn't ceremonial: it's the handoff payload. Colony captures it as one observation, the next agent reads it instead of re-deriving context, and mcp_metrics records the cost Stack: Node 20+, MIT licensed, stdio-based MCP server. Stores everything in ~/.colony/data.db. npm install -g /colony-cli colony install --ide codex colony health Repo: github.com/recodeee/colony Happy to answer questions or take roadmap suggestions in comments. The current pain points I'm working on next are auto-resolving same-file claim conflicts and a colony heal --apply that runs the fix-plan instead of just printing it. submitted by /u/KennGriffin [link] [comments]

Releasing the Data Analyst Augmentation Framework (DAAF) version 2.1.0 today -- still fully free and open source! In my very biased opinion: DAAF is now finally the best, safest, AND easiest way to get started using Claude Code for responsible and rigorous data analysis

https://preview.redd.it/o74lppqd86zg1.png?width=1456&format=png&auto=webp&s=3a904bae42b8130e2c6382be55debe8f6ef4d6ca When I launched the Data Analyst Augmentation Framework v2.0.0 six weeks ago, I wrote that the major update was about going “from usable to useful” -- rebuilding the orchestrator system for maximum flexibility and efficiency, adding a variety of more responsive engagement modes, and deepening the roster of methodological knowledge that DAAF could pull upon as needed for causal inference, geospatial analysis, science communication and data visualization, supervised and unsupervised machine learning, and much, much more. But while DAAF continued to get more capable and more useful for those actually using it… Well, it was still extremely annoying to use, generally obtuse, and hard to get started with, which means a lot of people who were interested were simply bouncing off of it. That all changes with the v2.1.0 update, which I’m cheekily calling the Frictionless Update for three key reasons: 1. Installation happens in one line now From a fresh computer to talking with a DAAF-empowered Claude Code in no more than ten minutes on a decent internet connection. This is really it: https://preview.redd.it/tiglwl3f86zg1.png?width=1038&format=png&auto=webp&s=3ec92cf797af5e0b91a2d46ef8cfb2976cbff802 Which means it’s easier than ever to get started with Claude Code and DAAF in a highly curated, secure environment. To that point, you still need Docker Desktop installed (I’ll talk about that more in a sec), but no more faffing about with a bunch of ZIP file downloads and commands in the terminal. The simplicity of this is even crazier, given that… 2. DAAF now comes bundled with everything you need to make it your main AI-empowered research environment No more messing around with external programs, installations, extensions, etc., it just works from the get-go with everything you need to thrive in your new AI-empowered research workflows with Claude from the moment you run the install line. https://preview.redd.it/q3pdj36g86zg1.png?width=1456&format=png&auto=webp&s=56ed822da68e773a9b7253ce6aa5a95abc057788 Thanks to code-server, DAAF automatically installs a fully-featured version of VSCode in the container, accessible in your favorite browser: file editing, version control management, file uploads and downloads, markdown document previews, smart code editing and formatting, the works. Reviewing and editing whatever you work on with DAAF has never been easier. DAAF also now comes with an in-depth and interactive session log browser that tracks everything Claude Code does every step of the way. See its thinking, what files it loads and references, which subagents it runs, and look through any code its written, read, or edited across any project/session/etc. Full auditability and transparency is absolutely mission-critical when using AI for any research work so you can truly verify everything its doing on your behalf and form a much more refined and critical intuition for how it works (and how/when/why it fails!). Some of the most important failure modes I’ve discovered with AI assistants (DAAF included) is it simply doesn’t load the proper reference materials or follow workflow instructions; this is the single most important diagnostic tool to identify and fight said issues, which I frankly think everyone should be doing in any context with LLM assistants. This took a lot of elbow-grease, but I think it’s the single most important thing I could do to help people actually understand what the heck Claude Code gets up to and review its work more thoroughly. https://preview.redd.it/jkocy45h86zg1.png?width=1456&format=png&auto=webp&s=6848b5a01ef958fa051a3246a1e6b13beef91e80 These two big new bundled features are in addition to installing Claude Code, the entire DAAF orchestration system, bespoke references to facilitate Claude’s rigorous application of pretty much every major statistical methodology you’ll need, deep-dive data documentation for 40+ datasets from the Urban Institute Education Data Portal, curated Claude permissioning systems and security defenses, automatic context and memory management protocols designed for reproducible research workflows, and a high-performance and fully reproducible Python data science/analysis environment that just works -- no need to worry about dependencies, system version conflicts, or package management hell. https://preview.redd.it/wzaotr5i86zg1.png?width=1456&format=png&auto=webp&s=91390402dfe3666a90472f6e878364ddcd1fb740 With the magic of Docker, everything above happens instantly and with zero effort in one line of code from your terminal. And perhaps most importantly (and why I will keep dying on the hill of trying to get people to use Docker): setting up DAAF and Claude Code in this Docker environment offers critical guardrails (like firewalling off its file access to only those things you explicitly allow) and security (like creating a convenient sy

Local MCP server that tells Claude Code what would break before it edits a file (raysense, MIT, free)

A pattern I keep hitting in Claude Code: I ask the agent to refactor something modest -- a parsing utility, a helper, a config loader -- and the diff it produces looks fine. Tests in the file pass. I run CI and three unrelated tests blow up. Sometimes the broken caller is code I have not touched in months. The agent is not careless. It read the file. What it could not do was see the codebase: the dependency graph, the call sites, the modules that lean on each other, the cycles, the test coverage of each piece. Plain text never reveals this. You cannot grep your way to "what would break if I delete this function." We built raysense to close that gap. It is a single Rust binary + Claude Code plugin + stdio MCP server that gives Claude structural memory of your codebase. Free, MIT-licensed, local-only -- no SaaS, no API key, no telemetry. It ships from crates.io and builds from source on first install, so the only prerequisite is a Rust toolchain (cargo) on the machine. If you don't have it yet: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh After that, cargo install raysense is the whole installation. (Disclosure: I am part of the team behind it. Posting because the problem comes up on r/ClaudeAI a lot.) What it does raysense scans the repo and persists 27 small columnar tables under .raysense/baseline/tables/: call graph, imports, cycles, complexity, hotspots, drift over time. The MCP server exposes that database to Claude Code through typed tools, plus a plugin with six skills mapped to phases of the work: bootstrap at session start: scan, save baseline. impact before an edit: blast radius, coupling, cycle exposure. verify after an edit: diff vs. baseline, what newly broke. audit on demand: whole-repo sweep, dead code, hotspots. drift across time: what got worse over the last 30 days. query as escape hatch: free-form Rayfall query language. Claude does not get a 4000-line architecture report. It gets the answer to a structural question, scoped to whatever it is about to touch. Languages raysense reads 69 languages out of the box across three tiers of analysis depth, mirroring what's on the coverage map: 11 tree-sitter built-ins with full AST analysis: Rust, C, Python, TypeScript, C++, Java, C#, Kotlin, Scala, Swift, Ruby. The 9 class-based languages also get type-inheritance graphs. Rayfall (the RayforceDB query language) joins the same tier via native S-expression extraction. 57 catalog plugins covering Solidity, COBOL, Elixir, Go, PHP, Lua, Haskell, OCaml, Erlang, Clojure, Zig, Nim, Crystal, Julia, R, MATLAB, Bash, PowerShell, SQL dialects, etc. - function and import extraction via configurable prefix patterns, no AST. Every cross-cutting metric on this page (blast radius, edit-risk, drift, evolution, hotspots) works at every tier. What the agent sees A typical impact call before an edit: ``` impact src/scanner.rs src/scanner.rs blast_radius: 34 files (top 5: cli.rs, mcp.rs, memory.rs, ...) fan_out: 12 fan_in: 18 cycles: 0 upward_violations: none edit_risk: medium Test files nearby: 3. ``` One MCP call. Claude reads that answer and writes the diff with the right caution. On refactors where the blast radius came back larger than expected, Claude has changed direction mid-edit and asked us first. How we built it (with Claude Code) raysense is a Claude-Code-built project end to end. The pattern: write a slice plan, Claude implements most of the first pass, review and ask for corrections, Claude reruns tests and smoke checks until green. The interesting twist is that we self-host the tool inside the sessions that build it -- the impact skill runs on raysense's own files before Claude edits them, so the agent knows the blast radius of editing the scanner code it is itself working on. That loop has been the biggest accelerator on the project. Why local-first Structural memory of a codebase is sensitive. Every file path, function name, and module shape ends up in the database. Pushing that to a third-party server so an agent could query it was never on the table for us. The whole design assumes the substrate sits next to the source and is queried over a stdio pipe. Side benefit: re-querying a saved baseline is microseconds. Nothing leaves the machine. Try it The fastest path is the new raysense install command. It auto-detects which Claude hosts you have on the machine (Claude Desktop, Claude Code, or both) and wires raysense in as an MCP server in one shot. One-liner: bash curl -fsSL https://raw.githubusercontent.com/RayforceDB/raysense/main/install.sh | sh Step by step instead: bash cargo install raysense # binary only raysense install # register MCP with whichever Claude hosts are present Force a single host when you want to be explicit: bash raysense install --desktop # only Claude Desktop (edits claude_desktop_config.json) raysense install --code # only Claude Code (delegates to `claude mcp add`) Claude Desktop, concretely. raysense i

Tired of fighting Claudes's bad habits from training?

I got really tired of constant permission prompts for dumb stuff like 2>&1 | when |& exists, or Claude using cat instead of the built-in Read tool, or ignoring my requests to use uv run instead of python3. Searched for a fix. Found one other post complaining. Nothing else. So I built a PreToolUse hook named claude-rubber-band, like snapping a rubber band on Claude’s wrist to get it to stop the bad habit. Matches patterns via Regex, denies the command, and crucially tells Claude what to do instead. That last part matters, it actually corrects itself rather than just retrying or giving up. Mine are opinionated and specific to me but the built-ins cover common stuff: cat file → use Read tool 2>&1 | → use |& sed -i → use Edit tool grep -r → use Grep tool git add -A → stage specific files Custom rules via JSON if you want to add your own (I block inline python scripts and require it actually make a script file with PEP 723 inline metadata and then use uv run to run it). Posting mostly so others can use the idea or the plugin itself: claude plugin install https://github.com/adamlogan73/claude-rubber-band submitted by /u/krakenant [link] [comments]

Claude will not finish this specific Deep Research task

For multiple days now, using multiple models and settings on claude.ai, I have been unable to get a successful deep research session back on the below prompt. It does the thinking, scans anywhere from ~750-2,000 sources, thinking/notes/progress all looks good. ...then it hangs...for hours. And then dies. Mostly with the red "Something went wrong" text. One time I saw the "Boom. research complete" note, but no document or summary was output. I've never had this with any other deep research task. Just seems to be this specific ask or something preventing it. Any ideas whats going on? --- # Deep Research Prompt: Complete Claude Code Capability & Configuration Atlas ## Role You are a meticulous technical researcher building the definitive, exhaustive, and **currently-valid** reference for everything that can be configured, customized, toggled, extended, or controlled in **Claude Code** (Anthropic's terminal-based agentic coding tool, package `@anthropic-ai/claude-code`). This is not a tutorial. This is a **complete capability atlas** — every knob, dial, file, flag, env var, hook, magic word, permission, integration, and undocumented-but-real feature. ## Objective Produce a single, comprehensive knowledge base covering **100% of Claude Code's configurable surface area**, with every entry **validated as present in the latest stable release** and **sourced** to an authoritative location. Anything deprecated, removed, renamed, or unverifiable must be **excluded** from the main catalog (and instead listed in a separate "Removed / Deprecated / Unverified" appendix with the evidence trail). ## Authoritative Sources (in priority order) 1. Official docs: `https://docs.claude.com/en/docs/claude-code/*` and `https://docs.anthropic.com/en/docs/claude-code/*` 2. Official GitHub repository: `https://github.com/anthropics/claude-code` — especially: - `CHANGELOG.md` (most recent entries define "latest") - `README.md` - Release tags / releases page - Open & recently-closed issues for behavioral edge cases 3. Anthropic engineering blog posts and announcements on `anthropic.com/news` and `anthropic.com/engineering` 4. The npm package metadata and any bundled `--help` output 5. Anthropic's Claude Code SDK docs (TypeScript and Python) 6. Anthropic Cookbook / reference repos under the `anthropics` GitHub org **Lower-trust sources** (community blogs, third-party tutorials, Reddit, X posts) may be used **only** to surface candidate features for investigation — every such candidate must then be re-verified against an authoritative source above before it earns a place in the main catalog. If a community claim cannot be authoritatively confirmed, file it under "Unverified." ## Scope — Categories To Exhaustively Cover For each category, enumerate **every** option, not just the popular ones. ### 1. Installation, Distribution & Runtime - Install methods (npm global, native installer, Homebrew, etc.) per OS - Supported OSes, terminals, shells, Node.js versions - Update mechanism, channel selection, version pinning - Uninstall and clean-state procedures - Working directory / trust prompts on first run ### 2. CLI Invocation - Every flag and option of the `claude` binary (e.g., `-p`/`--print`, `-c`/`--continue`, `-r`/`--resume`, `--model`, `--allowedTools`, `--disallowedTools`, `--permission-mode`, `--dangerously-skip-permissions`, `--output-format`, `--input-format`, `--verbose`, `--mcp-config`, `--add-dir`, `--session-id`, `--append-system-prompt`, etc.) - Subcommands (`claude config`, `claude mcp`, `claude doctor`, `claude update`, `claude migrate-installer`, etc.) — full subcommand tree - Stdin/stdout behavior, exit codes - Headless / non-interactive mode semantics - Streaming JSON input/output formats and schemas ### 3. Settings Files (Hierarchy & Schema) - Every settings file location and its precedence: enterprise managed → user (`~/.claude/settings.json`) → project shared (`.claude/settings.json`) → project local (`.claude/settings.local.json`) - Full JSON schema: every key, type, default, allowed values, scope - Examples include but are not limited to: `model`, `apiKeyHelper`, `permissions` (allow/deny/ask, additionalDirectories, defaultMode), `env`, `hooks`, `statusLine`, `outputStyle`, `cleanupPeriodDays`, `includeCoAuthoredBy`, `forceLoginMethod`, `disableAllHooks`, `enableAllProjectMcpServers`, `enabledMcpjsonServers`, `disabledMcpjsonServers`, etc. - How merging works across the hierarchy (override vs. union) ### 4. Environment Variables - Every recognized env var: `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, `ANTHROPIC_MODEL`, `ANTHROPIC_SMALL_FAST_MODEL`, `ANTHROPIC_BASE_URL`, `ANTHROPIC_CUSTOM_HEADERS`, `CLAUDE_CODE_USE_BEDROCK`, `CLAUDE_CODE_USE_VERTEX`, `CLAUDE_CODE_SKIP_BEDROCK_AUTH`, `CLAUDE_CODE_SKIP_VERTEX_AUTH`, `DISABLE_TELEMETRY`, `DISABLE_ERROR_REPORTING`, `DISABLE_NON_ESSENTIAL_MODEL_CALLS`, `DISABLE_AUTOUPDATER`, `DISABLE_BUG_COMMAND`, `DISABLE_COST_WARNINGS`, `BASH_DEFAULT_TIMEOUT_MS`, `BASH_MAX_TIMEOUT_MS`,

Claude Code v2.1.108's new hidden REPL tool is cool

Claude Code v2.1.108's new hidden REPL tool lets Claude explore the file system, use Haiku, and call tools, all using JavaScript code. It packs a bunch of convenient utility functions like sh(), haiku(), and gh(). This way it can perform many tool calls in one go and programmatically process their results, instead of waiting for each tool call to finish, looking at the raw output, and then finally processing the results. This could allow the model to get much more done in a single request, saving time and tokens. Check out https://github.com/Piebald-AI/claude-code-system-prompts/releases/tag/v2.1.108 for details. You can enable this tool if you have the native installation of CC v2.1.108 by setting the $CLAUDE_CODE_REPL environment variable to true. The idea is fairly simple, and has actually existed in Codex since February: https://github.com/openai/codex/pull/10674/changes#diff-1932608b6f26c4e004a975cceb12223f178502f6ecb550ac3a34e5b0f9ef3dd0. It reminds me of zx: https://github.com/google/zx. Instead of only being able to call tools like this: o.cwd = sh("pwd"); o.mdFiles = rg("^p?npm (start|dev)"); o.readme = cat("README.md") o is the output variable, and sh, rg, and cat are a few of several built-in utilities. Here's a fuller list: Shell & File sh(cmd, ms?) — run a shell command (optional timeout in ms) cat(path, off?, lim?) — read file content (optional offset and line limit) put(path, content) — write a file Search & Glob rg(pat, path?, {A,B,C,glob,head,type,i}?) — search for pattern (like ripgrep), returns match text rgf(pat, path?, glob?) — search for pattern, returns matching file paths gl(pat, path?) — glob for file paths GitHub gh(args) — runs gh with -R ${REPO} injected automatically AI haiku(prompt, schema?) — one-turn model sampling (lightweight AI call) Tool Bridging await Edit({...}) — call the Edit tool from within REPL await NotebookEdit({...}) — edit Jupyter notebooks await mcp__server__tool({...}) — call any MCP tool by its full name Custom Tools registerTool(name, desc, schema, handler) — register a custom tool unregisterTool(name) — remove a custom tool listTools() — list registered tools getTool(name) — get a specific tool Utilities log — console.log str — JSON.stringify shQuote(s) — shell-escape a string chdir(path) — change working directory for the REPL call REPO — the current repo in owner/name format Special rules `Variables persist across REPL calls `No import/require/process/Node globals sh/cat/rg return error text on failure (never throw) rgf/gl return [] on failure (never undefined) I think REPO being automatically injected is clever. The haiku utility and being able to await mcp__server_tool() are both really cool, and the idea of Claude registering custom tools is intriguing. The idea of providing a frictionless way to execute arbitrary JavaScript code is powerful because Claude is already great at coding, and in complex situations it already tends to try to write JavaScript or Python scripts to inspect its environment, and often it has trouble doing so because of shell quoting and escaping issues, python3 vs. python vs. py, etc. submitted by /u/Dramatic_Squash_3502 [link] [comments]

Claude Code asking me to switch models mid-stream, if I turn an Opus conversation into a Sonnet one does it lose all the Opus context?

submitted by /u/futurestack-ai [link] [comments]

I built a CLI that scans your project and auto-installs matching skills for Claude Code

Hey r/ClaudeAI — I built a small tool to fix something that bugged me: every time I start a new project, picking the right skills from skills.sh is manual and slow. skillgrab does this: Scans `package.json`, `requirements.txt`, `pubspec.yaml`, `go.mod`, `Dockerfile`, `vercel.json`, etc. to detect your stack Reads your README for non-code hints ("landing page", "pricing", "SEO") and asks if you want marketing/design/sales skills Queries skills.sh live, ranks results (trusted owners + install count), dedupes by skill name Validates each candidate against GitHub before installing (the search API sometimes returns slugs that don't exist in the actual repo) Installs via `npx skills add` — grouped by source repo, one clone per repo, targets `~/.claude/skills/` by default One command, zero config: ``` npx skillgrab ``` Or `npx skillgrab --dry-run` to preview first. - Landing: https://briascoi.github.io/skillgrab/ - Code (MIT): https://github.com/briascoi/skillgrab - npm: https://www.npmjs.com/package/skillgrab Would love feedback — especially on detection heuristics for stacks I don't have fixtures for yet. submitted by /u/briascoi [link] [comments]

I built a Mac dictation app that injects voice + screenshots + clipboard straight into Claude Code mid-sentence

Hey r/ClaudeAI 👋 I'm Marek, and I've been building a Mac dictation app called Spoke. There are a lot of dictation apps out there and I'm not going to pretend mine is the right one for everyone — but if you do a lot of coding, live in Claude Code, and like tools you can shape to your workflow, I think you'll find this interesting. Short video of the Claude Code part below. The post explains the rest. The basic idea Spoke is built around flows. A flow is a pipeline of composable steps that run on your audio — transcribe, AI-process, inject somewhere. The simplest flow is "transcribe → inject text at cursor" (i.e. every other dictation app). But you can build flows that do a lot more, and the one I want to talk about is the Claude Code flow. Trigger model is up to you per flow: hold-to-talk, or tap-to-start / tap-to-stop. You can bind keyboard shortcuts or mouse buttons (I use mouse 5 for general dictation, right-Cmd for Claude Code). Transcription runs fully on-device. The Claude Code integration (the actual point of this post) Setup is two commands. First, register Spoke as an MCP server: claude mcp add spoke -s user -- /Applications/Spoke.app/Contents/Helpers/claude-channel-bridge (The -s user scope registers Spoke globally so you don't have to re-add it per project.) Then launch Claude Code with the experimental channels flag: claude --dangerously-load-development-channels server:spoke The flag is required for now because channels are still an experimental Claude Code feature. First time you connect a session, Spoke and Claude do a PIN pairing handshake. The channel is signed and authenticated, the key lives in your macOS keychain scoped to that process. Pair once per session, "remember" if you want it permanent. Now here's the part that's hard to explain in text (which is why there's a clip): You hit your trigger key from anywhere — browser, Figma, wherever — and talk to Claude Code without ever focusing the terminal. Voice goes straight into the running session. Standard so far. But Spoke also lets you inject screenshots and clipboard contents inline, mid-sentence. You're talking, you hit the screenshot shortcut, you keep talking, you hit the clipboard shortcut, you keep talking. When the message lands in Claude Code, the attachments are positioned at the exact moment in the sentence where you triggered them. So you can say things like: "Make the page background match this color [screenshot] and use this image as a logo [clipboard] — also add a carousel with these images [clipboard with 4 files selected]." Claude gets a single coherent message with all five attachments in the right slots. It just works. There's a history view in Spoke that shows every transcription with the attachment icons sitting between the words, in the exact positions — so you can see what got sent and where. Useful for debugging your own brain when something didn't land right. Multi-session If you're running multiple Claude Code sessions in parallel (different repos, different terminals), each pairs separately and Spoke pops a picker when you trigger the flow — IP, PID, working directory for each one. Pick which session to send to, or check "remember for this flow" and it sticks. Codex / Ghostty works too The Claude Code flow has an output step you can swap. Instead of routing through the MCP channel, you can route to a Ghostty terminal window — Spoke types into whatever's running there and presses enter. Codex, plain shell, whatever. Same voice + screenshot + clipboard injection model. (Ghostty-only for now because the standard macOS Terminal doesn't expose the APIs I need. If you haven't tried Ghostty — it's Mitchell Hashimoto's terminal, GPU-accelerated, open-source, worth the switch on its own merits.) Link: https://usespoke.app/ Happy to answer any technical questions about the channel protocol, the Parakeet pipeline, the flow architecture, why I made specific tradeoffs — whatever. I built the whole thing solo so I can go deep on any of it. If you try it and hate it, tell me why. If you try it and like it, even better. — Marek submitted by /u/stoprocentdoc [link] [comments]

I built a Claude Dungeon Master skill that runs persistent D&D 5e campaigns — here's how the architecture works

Following up on my post last week - I published a bunch of new features today that should make the experience more broadly accessible, so I thought it was a good time to share. Figured this audience would appreciate the engineering side more than the gameplay side. What it is: A Claude Code skill that turns Claude into a persistent, session-aware D&D DM. The interesting problems weren't the D&D part — they were the LLM architecture problems underneath it. Context management A full campaign has world state, NPC memory, faction tracking, combat history, character sheets, session logs, and a growing archive. Loading all of it every turn would blow the context window immediately. The solution is a layered read strategy: a slim index loads at session start, a keyword search script campaign_search.py runs before any full file read, and only the relevant slice escalates to context. The model never sees more than it needs for the current turn. NPCs are part of the same stateful world problem. Every NPC carries role, stat block, demeanor, motivation, secret, and speech quirk. Attitudes persist on a 5-step scale (hostile → unfriendly → neutral → friendly → allied) with logged reason and date — so the world remembers not just what happened but how it changed who. Behavioral constraints as hard rules The DM persona isn't a system prompt that says "be a good DM." It's a set of twelve applied behavioral standards written as active constraints — things like structure situations not plots, the world moves without the player, and make the player feel consequential. The distinction matters: aspirational language drifts under pressure. Constraint language doesn't. Every session turn is evaluated against them. The display companion An optional Flask SSE server streams narration, dice results, NPC dialogue, and character stats to any screen on the LAN — TV, tablet, phone, second monitor. Scene detection scans narration for keywords and crossfades background gradients and particle effects (17 scenes). A send.py pipeline handles typed sends with styled distinctions: player action, dice roll, DM narration, NPC dialogue each render differently. All audio synthesis runs via numpy — no audio files needed for ambient sound and SFX. The server buffers the last 60 chunks to disk. Reconnecting browsers (Chromecast drop, tab refresh) replay the full session automatically — no narration lost. There's also a ◈ DM Help button that reads the last 8 display chunks plus current campaign state, calls Claude in non-interactive mode, and returns a one-shot contextual hint via the SSE pipeline. Clean illustration of the on-demand vs. always-on cost trade-off — hints only cost tokens when someone asks for one. Autorun / player input queue Players submit actions through the display companion's input panel. A polling loop watches a sanitized queue file and feeds it back to Claude as the next turn's input — no PTY wrapper, no terminal forwarding. Claude drives the turn loop autonomously, blocking between turns with a wait script, picking up queued input when it arrives. Skill system The whole thing is packaged as a Claude Code skill — a structured SKILL.md the model loads on /dnd load, with separate reference modules for script syntax and command procedures. Python helper scripts handle all calculation (dice, combat initiative, XP, calendar, stat blocks) so the model never does math. The honest experience I built this selfishly — I wanted a specific experience with my family and couldn't get it any other way. I'm sharing because the results have genuinely surprised me. We've had moments that ranged from laugh-out-loud to quietly eerie, the kind that don't happen unless the fiction has real weight. My wife and I have a long-running two-player campaign I tailored to her literary interests at world-gen, and it's been one of the better things we've done together. Solo play has replaced most of my fiction reading and solo gaming time. I know others could get something real out of it. Full open source: https://github.com/Bobby-Gray/claude-dnd-skill Happy to go deep on any of the design decisions. A few of them were non-obvious. submitted by /u/Bobby_Gray [link] [comments]