UiPath AI

UiPath AI AI

UiPath AI AI

UiPath AI AI

UiPath AI AI

UiPath AI AI

UiPath AI AI

UiPath AI AI

UiPath AI AI

UiPath AI AI

UiPath AI AI

I stress-tested Kimi K2.6 against Claude Opus 4.7 on a quick coding-agent task

I tested Claude Opus 4.7 and Kimi K2.6 on the same coding agent task i.e. build an AI Fix Runner that takes a broken repo, runs its tests, identifies the failure, applies a patch, reruns the test, and exposes the final diff/logs through an API and UI. The goal was not to benchmark syntax completion or simple repo edits. I wanted to test model behavior on a less familiar integration path: shifting execution from local processes into remote sandboxes. I used Tensorlake specifically because the sandbox API is newer and integration-heavy. This made the test more about whether the model could reason through unfamiliar infra and produce a working implementation. Setup: Claude Opus 4.7 through Claude Code Kimi K2.6 through OpenCode via OpenRouter Pricing context: Claude Opus 4.7: $5/M input, $25/M output Kimi K2.6: $0.95/M input ($0.16 cached input), $4/M output So, what made it interesting is if Kimi's lower cost can handle a crazy workflow. To be clear, comparing Kimi K2.6 directly with Opus 4.7 is not completely fair. The model classes, pricing, and expected capability levels are very different. I mainly wanted to see how far an open model could get on the same task at a fraction of the price, and whether the performance/price tradeoff made sense for coding-agent work Test 1: Local AI Fix Runner First, both models had to build the local version. The app needed to: create fixture repos with intentional bugs run install/test/build locally capture stdout/stderr apply patches rerun tests after patching expose run state through backend APIs show logs and patched source in the UI reject obviously unsafe commands Claude Opus 4.7 produced a working implementation. It built the fixture repos, repair flow, API endpoints, UI, logs, and patched-file inspection. The main pipeline worked: install -> test fails -> patch -> test passes -> build passes It had one real bug: workspace persistence. KEEP_WORKSPACES=true was supposed to preserve the final workspace, but the backend loaded .env from the wrong location. One follow-up fixed it. Kimi K2.6 got some backend pieces working and could trigger repair runs, but the implementation was incomplete. The biggest miss was patched-source inspection, which is core for this app because you need to verify exactly what the agent changed. Rough numbers: Opus: $13.84, around 39 min wall time Kimi: around $3.40, around 1h 39 min wall time Result: Opus did it good, Kimi could not The difference in the price, and the time taken is just insane. Test 2: Sandbox Integration Second, I asked both models to move execution from local processes into Tensorlake Sandboxes. This was the main stress test. The model had to: create a sandbox copy the repo into the sandbox execute install/test/build remotely capture logs from sandbox commands apply patches inside the sandbox rerun validation clean up sandbox state keep the original local runner working This is where I wanted to test performance on something newer and less likely to be in the model’s training data. Claude Opus 4.7 handled this cleanly. It added a Tensorlake runner, kept the local runner abstraction intact, wired env/config handling, and created a live test path using TENSORLAKE_API_KEY. More importantly, the local regression path still passed after the sandbox backend was added. Kimi K2.6 was given the working Opus local implementation as the base, so it only had to add Tensorlake execution. Even with that advantage, it failed to produce a clean sandbox flow after 150k+ tokens. It got stuck around the integration layer and never reached a reliable test/build/patch loop inside Tensorlake. Rough numbers: Opus Tensorlake run: around $24.39, around 23 min Kimi Tensorlake run: failed after a long run, 150k+ tokens Result: Opus passed, Kimi failed Takeaway Kimi K2.6 is much cheaper and can handle some bounded coding work, but it struggled once the task involved external execution infra, sandbox lifecycle, env/config handling, and regression safety. Claude Opus 4.7 was expensive, but much stronger at: preserving architecture adding a new execution backend handling config bugs maintaining testability reasoning through unfamiliar infra For me, this was less about “which model writes code” and more about “which model can integrate a newer system without breaking the app.” On that specific test, Opus was clearly miles ahead. Full breakdown with prompts, code, screenshots, demos, and cost details: https://www.tensorlake.ai/blog/claude-opus-4-7-vs-kimi-k2-6-real-world-coding-test Curious if anyone has gotten Kimi K2.6 working reliably on coding-agent workflows. submitted by /u/shricodev [link] [comments]

Reconsider using Claude, hit by too many false positive blocks, and hundreds of user reports

https://preview.redd.it/hevkfnz46v2h1.png?width=3170&format=png&auto=webp&s=0abde4ef1d7d647da9e376db88ef4ae5f429c5e9 reproducible example: claude -p "please read source https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/modules/device_orientation/device_motion_event_pump.cc and explain to me" related issues on github: False positive policy block on OSS governance/security files (CodeQL, CODEOWNERS, CoC) #61688 [BUG] CVP repeatedly declines homelab sysadmins — no path for infrastructure owners managing personal hardware #61668 [Bug] Safety classifier blocks routine code analysis for paid users (started 2026-05-23) #61664 [BUG] False positive - legitimate medical-education content flagged as unsafe #61663 False-positive Usage Policy block mid-session (req_011CbJudbehY5Yi6gtM4xko4) #61660 [BUG] Persistent false-positive AUP violation blocks entire AI research project (Opus 4.7) #61659 [Bug] Anthropic API Error: Usage Policy violation blocking TTRPG content in Claude Code CLI #61658 False-positive content filter blocks benign UI animation prompts in Claude Code #61657 [Bug] Anthropic API Error: Overly aggressive Usage Policy filtering on biomedical research requests #61656 [BUG] AUP repeatedly throwing false positives - live issue ongoing - hundreds of similar reports #61655 [BUG] AUP false positives during scientific manuscript editing request #61654 [BUG] : API Error: Claude Code is unable to respond to this request, which appears to violate our Usage Policy #61653 False positive: Usage Policy block on technical markdown integration task #61652 [BUG] Safety classifier repeatedly blocks legitimate constructed language (conlang) development #61650 False-positive cyber-safeguard intervention on legitimate systems-engineering work in Claude Code #61646 [BUG] erroneous API Error: Claude Code is unable to respond to this request #61645 [BUG] False positive safety block: triggered without apparent reason during game dev session #61644 submitted by /u/jimages [link] [comments]

Managed Agents self-hosted sandboxes - what's new in CC 2.1.145 (+20,218 tokens)

NEW: Data: Managed Agents self-hosted sandboxes — Adds reference documentation for self_hosted Managed Agents environments, covering outbound worker polling, environment keys, SDK and CLI worker paths, webhook-driven wakeups, orchestration, monitoring, cloud-vs-self-hosted differences, credential handling, and customer-owned security responsibilities. NEW: Skill: Run app — Adds a general skill for launching and driving a project's actual runtime surface, first preferring project-specific run skills and otherwise choosing patterns for CLIs, servers, browser apps, Electron apps, TUIs, and libraries. NEW: Skill: Run skill generator — Adds guidance for creating project-specific run- skills, including verified setup/build/run steps, driver or smoke-harness creation, clean-environment verification, and examples for browser, CLI, Electron, library, TUI, and server/API projects. NEW: Skill: Run skill template — Adds a reusable template for project-specific run skills with sections for prerequisites, setup, build, agent and human run paths, tests, gotchas, and troubleshooting. NEW: Skill: Run browser-driven web app example — Adds an example run skill pattern for web apps that starts a dev server, waits on real readiness, drives it with chromium-cli, captures screenshots, and records recurring gotchas. NEW: Skill: Run CLI tool example — Adds an example run skill pattern for CLI tools covering installation, representative invocations, expected output, exit codes, and stdin behavior. NEW: Skill: Run Electron desktop GUI app example — Adds an example run skill pattern for Electron apps that launches under xvfb, exposes a Playwright-driven REPL, captures screenshots, and documents desktop automation pitfalls. NEW: Skill: Run library SDK example — Adds an example run skill pattern for libraries and SDKs focused on build/test steps plus a minimal public-boundary smoke example. NEW: Skill: Run TUI interactive terminal app example — Adds an example run skill pattern for terminal UIs using tmux to launch, send input, capture panes, document key commands, and clean up. NEW: Skill: Run web server API example — Adds an example run skill pattern for servers and APIs with background launch, readiness polling, smoke curl verification, and shutdown guidance. REMOVED: System Reminder: Plan mode is active (iterative) — Removes the iterative plan-mode reminder that told agents to maintain a plan file while repeatedly exploring, updating the plan, and asking the user questions before exiting plan mode. Agent Prompt: Managed Agents onboarding flow — Updates the introductory Managed Agents explanation to include self_hosted environments where the user's own worker runs tool execution, and distinguishes cloud environment networking/packages from self-hosted infrastructure. Agent Prompt: /review-pr slash command — Changes the PR detail command to request specific JSON fields from gh pr view, including title, body, author, refs, state, diff stats, changed file count, and labels. Agent Prompt: Status line setup — Adds repository identity and current-branch PR metadata to the status-line input schema, with examples for displaying owner/name and PR number/review state. Data: Anthropic CLI — Adds self-hosted environment CLI references for ant beta:worker poll/run and ant beta:environments:work stats/stop. Data: Claude Platform on AWS reference — Clarifies that Claude Platform on AWS has first-party API parity except for self-hosted sandboxes, which are unavailable there and should use cloud environments instead. Data: Live documentation sources — Adds Managed Agents self-hosted sandbox and self-hosted sandbox security documentation URLs to the live documentation source list. Data: Managed Agents core concepts — Documents sessions.update() for changing agent.tools, agent.mcp_servers, and vault_ids on an idle existing session as a session-local override. Data: Managed Agents endpoint reference — Adds self-hosted environment work queue endpoints and clarifies that session updates can replace tools, MCP servers, and vault IDs; also notes that self-hosted environment configs are just {"type":"self_hosted"}. Data: Managed Agents environments and resources — Replaces the old restricted-networking example with limited networking plus allow_package_managers and allow_mcp_servers, and adds self-hosted sandbox guidance for running tool execution in user-controlled infrastructure. Data: Managed Agents overview — Adds self-hosted sandboxes as a use case and updates environment guidance so config.type can be either cloud or self_hosted; also points to sessions.update() for per-session tool/MCP/vault changes. Data: Managed Agents reference — cURL — Updates the environment creation example to use limited networking with package-manager and MCP-server allowances. Data: Managed Agents tools and skills — Clarifies where prebuilt agent tools and MCP tools run for cloud vs. self-hosted environments, and adds notes about session-local tool/MCP/

Opus 4.6/4.7 regression is real and getting worse — 3 weeks of documented failures on a complex project, and a competing AI caught the mistakes Claude missed [long post]

I've been running Claude Pro (Opus 4.7 / Sonnet 4.6) for about 3 weeks on a complex personal AI infrastructure project. I keep structured session logs with timestamps and Birkenbihl-style metacognitive fields after every session. This is not anecdotal — I have receipts. The project for context I'm building a local persistent AI memory stack called GSOC Brain: Qdrant vector DB (~397K vectors across 11 source tags), Neo4j graph (123 nodes / 183 edges), Graphiti 0.29 entity extraction, Ollama with qwen2.5:14b + nomic-embed-text — all running natively on a Windows host. The system is supposed to give Claude cross-chat memory via a custom MCP server. On top of that, I'm operating 18+ custom skill files that define behavior rules for Claude across domains (OSINT/forensics, legal, content, infrastructure). The system prompt explicitly describes the full architecture on every session start. This is not a "chat with Claude" use case. This is sustained agentic work across multiple tools, multiple sessions, strict context requirements, and high-stakes outputs (including legal document drafts). Bug 1: Token overconsumption since update 2.1.88 (late March 2026) Opus 4.7 started burning daily usage limits at a completely different rate after an update around March 31. In one session I hit 94% of my daily limit within approximately 4 messages. The boot sequence — fetching context from Notion MCP, searching past sessions, loading memory — consumed what felt like 10–20x the previous token rate. GitHub issues #42272, #50623, and #52153 document identical patterns from other users. The model appears to over-generate internally even for simple responses. End result: I had to switch to Sonnet 4.6 for most productive work because Opus 4.7 is simply unusable under the daily limit. Bug 2: Claude Code Desktop App completely broken (reported May 14, Conv. 215474208295333) The Desktop App hangs on every single input. Including typing "hello" with no files. Reproducible across: Sonnet 4.6 and Opus 4.7 Multiple fresh sessions With and without u/file references After full reinstall The VS Code extension works fine. Only the Desktop App is broken. Reported May 14. No fix, no acknowledgment. Bug 3: Platform / context confusion — 5 documented errors in a single session, chat aborted On April 29, I had to formally abort an Opus 4.7 session and hand off to Opus 4.6 after documenting 5 consecutive errors. The session log entry literally reads "Opus 4.7 Abbruch (5 Fehler): Zeitrechnung, Platform-Verwechslung, falsche Schlüsse": Miscalculated the current time despite being told the exact time Insisted the Brain stack was running on a Linux VM (BURAN) — the system prompt and memory both explicitly stated C:\gsoc-brain on Windows Drew false inferences from backup file paths rather than the stated architecture Contradicted the stated platform in the same response it had just received Confused WebClaude and Desktop Claude capability boundaries These aren't edge cases. The architecture was in the system prompt, in memory, and in the injected Notion context. Opus 4.7 ignored all of it. Bug 4: Skill files ignored in production I maintain 18+ custom skill files loaded into the system prompt. These include explicit hard rules — e.g., "activate keilerhirsch-knowledge skill for ALL architecture decisions, web search is not optional." In the session that caused the Docker-to-Native migration disaster, I later wrote in my own session log: The model proceeded to recommend outdated tools from training data rather than searching current documentation. It recommended NSSM (last meaningful update 2017) as a Windows service wrapper. NSSM is dead. A competing AI caught this immediately. Bug 5: Another AI caught what Claude missed in a single pass This is the part that stings most. When the Docker-based Brain setup kept failing, I fed the architecture docs into another AI (Manus) for a deep audit. In one pass it identified 5 critical corrections that Claude had never caught across weeks of sessions: NSSM is dead since ~2017 → correct replacement is WinSW or Servy Neo4j 2025.01+ requires Java 21 — Claude had never flagged this, the services kept failing silently Qdrant needs Windows file-handle-limit adjustments to run reliably Orphaned vector risk between Qdrant ↔ Neo4j without a Tentative-Write pattern in the save operation BGE-M3 embeddings (MTEB 63.2, 8192 token context) as a better alternative to nomic-embed-text My own session log the next day reads: Claude was answering from stale training data. The skill that explicitly says "don't do this" was being ignored. Another AI caught it in round one. Bug 6: MCP Server 20-minute Neo4j hang — still unresolved After the native migration, the custom gsoc_mcp_server.py developed a reproducible hang of exactly ~20 minutes between Qdrant connect and Neo4j connect on every startup. Log timestamps from 4 consecutive restarts: 14:59 → 15:20 (21 min) 15:29 → 15:51 (22 min)

Four backend concepts for Product Managers using Claude Code

You don't need to write backend code. But if you understand how backend systems behave, your prompts get dramatically better because you're speaking the same language as the system. Async vs Sync: user clicks "generate," you call OpenAI, it takes 3-5 seconds. If that's synchronous, the entire UI freezes, Nothing responds. The fix is to make the call async. Show a loading state immediately, let the user keep interacting, update the screen when the response arrives. Tell Claude Code "handle this asynchronously" and watch the output quality jump. Race conditions: two users click "claim this spot" on the last available slot at the same second. Backend reads the database, sees one spot, confirms both. Now you have a double booking. You don't need to write the fix, but you need to spot this pattern in your specs. Anytime a user action reads a value then updates it, ask one question: what happens if two users do this at the same time? The fix is an atomic transaction read and write happen as one indivisible operation. Idempotency user submits a form, internet cuts out for half a second. Did it go through? They don't know, so they click again. Without idempotency, you now have two records. With it, the second request returns the same result without creating a duplicate. The fix is an idempotency key is unique ID generated on the frontend, sent with every request. Backend checks if it already processed that key. Stripe uses this for every payment call. Graceful degradation: your app calls OpenAI and the API is down. If you haven't planned for this, users see a blank screen or a raw error code. Every feature needs three states: happy path (everything works), loading state (we're waiting), error state (something failed). Retry up to three times. If it still fails, show a friendly message and keep the rest of the page working. Never let one dependency take down the whole experience. TLDR: Next time you're in Claude Code, try using these terms in your prompt — "handle this asynchronously," "make this endpoint idempotent," "add graceful degradation." The output gets significantly better when you speak the system's language. Post inspired from this video, you can checkout SkillAgents AI on Youtube for similar content. submitted by /u/InfamousInvestigator [link] [comments]

Good AI-assisted development happens at the systems level, not the task level

Every time I add a new feature to my Phoenix app, my AI coding agent ships the feature... but doesn't add a menu item for it. The page exists, the functionality works, but there's no way for a user to actually get there. My first instinct, like everyone's, is to go tell the model "add the button." And that works. But think about what just happened: I noticed a problem, diagnosed it, and told the model exactly what to do. I'm doing the thinking. The model is doing the typing. I'm pedaling the Peloton so Anthropic can give me free tokens. That's the promise of "prompt engineering" — you get better at telling the model what to do. But you're still working for the model. We want the model working for us. Here's the difference. Instead of telling the model to add the button, I ask: how do I make this mistake impossible in the future? I use BDD specs that define what my app should do at its boundaries. The Phoenix LiveView test helpers have a navigate function that lets the agent jump directly to any page — which means it can make tests pass without ever touching the UI. So here's what I did: I wrote a linter rule that prevents the agent from calling navigate. Now there's an allowed fixture that drops the test on a known starting route, and the only way the agent can reach my new feature is by clicking through the UI — which forces it to add the menu item to make the test pass. I will never have this problem again. Not because I wrote a better prompt. Because I changed the system so the correct behavior is the only possible behavior. That's the shift. Stop fixing the model's output. Start constraining its environment so the right output is the path of least resistance. Every mistake is a chance to design out the next one, not a chance to write a better prompt. submitted by /u/johns10davenport [link] [comments]

I cancelled my AI notetaker subscription and built my own tool using Claude Code. It works well (and it's free)

It does what Fathom, Otter, and Fireflies charge $15–$30/seat/month for. I shipped a fully working AI meeting note-taker last weekend. I use this exact setup to Records calls then transcribes and Summarizes key points, it then pulls action items and then creates shareable notes all whilst running inside my Claude workflow. . The whole setup takes one weekend to build. --- Here’s how it works:(you can copy this exactly) Step 1 → Fork the repo, drop into Cursor Step 2 → Set env vars: transcription key, database URI, admin creds, session secret Step 3 → Record or upload your meeting Step 4 → The audio gets transcribed Step 5 → Claude turns the transcript into structured notes, decisions, follow-ups, and action items Step 6 → Click “Share link” → send anywhere Total build time: ~1 weekend. Cost: $0/month. --- Why the 5-piece stack is the unlock? Most "build your own SaaS" attempts fall flat because they bolt features together without designing the user flow first. This stack works because the data path was decided before any UI got rendered. Every SaaS feature you pay for has a primitive underneath. Loom = browser recorder + S3 + share links. Otter = Whisper API + database + UI. Calendly = a calendar API + booking page. The features stopped being moats the moment Cursor + Claude could write the glue in an afternoon. You're not paying for technology anymore you're paying for distribution and brand. That's why this build pattern works. The assembly is now free. --- Why Claude? Because meeting notes are not just summaries. They need context. Claude can take a raw transcript and turn it into: * decisions * objections * follow-ups * action items * CRM-ready notes * client context * internal operating memory That is where the value is. --- https://github.com/albertshiney/utter_public submitted by /u/Tabani897_YT [link] [comments]

SendUserFile tool for surfacing generated deliverable files to the use - what's new in CC 2.1.142 (+1,080 tokens)

NEW: Tool Description: SendUserFile — Describes the SendUserFile tool for surfacing generated deliverable files to the user, with optional captions and normal or proactive status. Agent Prompt: Coding session title generator — Wraps the session content in tags and tells the model to treat it as data, not follow links or instructions inside it, and not state inabilities. If the content is just a URL or reference, it should describe what the user is asking about (e.g. "Review Slack thread") rather than refuse. Adds a "Bad (refusal)" example. Agent Prompt: Managed Agents onboarding flow — Adds a "Console escape hatch" instruction telling the runtime code to print the session's Console URL right after sessions.create() so users can watch the session in the UI while iterating, defaulting the workspace slug to default. Agent Prompt: /rename auto-generate session name — Wraps the conversation content in tags and instructs the model to treat it as data to summarize, not instructions to follow. Data: Live documentation sources — Adds a WebFetch URL for the Amazon Bedrock documentation page, covering the AnthropicBedrockMantle client, anthropic.-prefixed model IDs, auth paths, feature availability, and regions. Data: Managed Agents core concepts — Adds a "Watch it live in Console" tip pointing at https://platform.claude.com/workspaces/{workspace}/sessions/{session.id}, with default as the fallback workspace slug, and asks generated code for locally-iterating users to include the print/console.log of that link. Skill: Create verifier skills — Swaps the hardcoded TodoWrite tool reference for one that resolves to either TaskCreate or TodoWrite depending on whether the tasks feature is enabled. Skill: Model migration guide — Adds an Amazon Bedrock model IDs section explaining that Bedrock clients use the same Messages API and breaking changes but require an anthropic. provider prefix on model IDs, with a rename table for claude-opus-4-7 and claude-haiku-4-5. Notes that code_execution_* tool versions and Task Budgets are first-party-only and should be skipped for Bedrock, and warns that the legacy InvokeModel/Converse Bedrock integration with ARN-versioned IDs is out of scope. Details: https://github.com/Piebald-AI/claude-code-system-prompts/releases/tag/v2.1.142 submitted by /u/Dramatic_Squash_3502 [link] [comments]

I built a daily thought app with Claude Code, including a line-art system drawn entirely in SwiftUI

I built an iOS app called One Good Thing with Claude Code as my main coding partner. It is free to try, and the core daily card experience is free. The idea is simple: one thoughtful card per day, under two minutes. You either Carry it or Let Go, then close the app. No feed, no endless scroll, no pressure to stay inside it. What I thought might be interesting for this sub is not just the app, but one part of the build process: every illustration in the app is drawn in code. No pencil. No tablet. No image file. Each hand, bird, window, thread, dot, and curve is a SwiftUI Canvas path. The result is meant to feel hand-drawn, but it is all coordinates and Bezier curves. Claude helped in a few specific ways: Turning vague visual direction into first-pass SwiftUI Canvas paths Refactoring repeated drawing logic so the illustrations stayed consistent Catching SwiftUI edge cases, especially around view state, animations, and previews Helping me reason through Firebase, StoreKit, Cloud Functions, App Check, and Firestore rules without losing the product shape The workflow that worked best was not "make me an illustration." It was more like: Describe the feeling of the screen in plain language Ask Claude for a rough Canvas implementation Run it in the app Manually tune the coordinates until it felt less like an icon and more like a small mark someone might pause on Ask Claude to simplify or make the code safer once the direction felt right The biggest lesson for me was that Claude is much better when I treat it like a patient pair programmer, not a vending machine. It can get a first draft on screen very quickly, but the taste still has to come from you. The useful loop was: generate, inspect, adjust, reduce. The app itself also uses Claude-assisted code across the stack: SwiftUI for the iOS app, Firebase Cloud Functions, Firestore security rules, a Next.js landing page, and some AI reflection features for subscribers. But the line-art system is probably the most visible place where the collaboration shows. Would love feedback on: Whether the coded illustration idea comes through Whether this is a useful example of Claude Code beyond CRUD/app boilerplate What you would have done differently in the Claude workflow Free to try, core daily card is free. https://apps.apple.com/app/one-good-thing-daily-thought/id6759391105 submitted by /u/Evening-Strike-2021 [link] [comments]

I had Claude build a custom xAI TTS integration for Home Assistant — here's the repo

I wanted to use xAI's new TTS API (Eve voice) in my Home Assistant voice pipeline instead of OpenAI. Rather than write it myself, I worked with Claude to build the integration through conversation — describing what I needed, hitting errors, iterating on fixes. Claude wrote all the code. The result is a working custom component with a full UI config flow, all five xAI voices (Eve, Ara, Rex, Sal, Leo), and support for xAI's expressive speech tags like [pause], [laugh], , , etc. Eve is genuinely good — noticeably more expressive than OpenAI's Ballad voice for longer content, and at the same price point ($15/1M characters). The main technical challenge was that HA's modern TTS platform requires async_stream_tts_audio returning a TTSAudioResponse — the older async_get_tts_audio path silently fails in voice pipelines. That took a while to figure out and isn't well documented. Repo: https://github.com/therealakahn/ha-xai-tts Happy to answer questions. No HACS support planned — it's provided as-is. submitted by /u/mennzo [link] [comments]

Usage4Claude 3.0.0: open source macOS menu bar usage tracker for Claude, now with Codex support

Hi r/ClaudeAI, I posted an early version of Usage4Claude here a few months ago. I just released 3.0.0, so I wanted to share the update instead of pretending it is a brand new project. Usage4Claude is a native macOS menu bar app I made for keeping an eye on Claude subscription usage. It shows the current limits in the menu bar, opens a small detail window on click, and stores auth locally in macOS Keychain. It is free and open source. The main 3.0.0 change is optional Codex support. If you only care about Claude, nothing extra needs to be configured. If you also use Codex, you can add that account in settings and see Claude and Codex side by side. What changed since the first post: Claude can show the 5 hour, 7 day, Extra, 7 day Opus, and 7 day Sonnet limits when that data is available. Codex can show 5 hour, 7 day, and Extra Usage credits. Built in browser login is available for Claude, so manual cookie/session digging is no longer the main path. Multiple Claude accounts and organizations are supported, plus separate Codex account switching. Notifications can warn at 90 percent usage and when usage resets. French localization was added, along with English, Japanese, Chinese, and Korean. I built most of this with Claude Code as my main coding partner. It helped with the SwiftUI work, refactors, localization passes, and the boring edge cases around refresh state. I also used Codex on some of the implementation and review work. GitHub repo: Usage4Claude Release: v3.0.0 A small privacy note: it runs locally, does not collect analytics, and only makes usage related requests. Claude session data and Codex auth tokens are stored in Keychain. It is also an independent tool and is not affiliated with Anthropic or OpenAI. Happy to answer questions or hear bug reports. If anyone tried the earlier version, I would especially like to know whether the new login and multi account flow feels less annoying. submitted by /u/f-i-sh [link] [comments]

Where I'm at with AI Assisted Building + Current and Future Workflow Overview

I've been in an AI dive bomb for probably a couple of years now. The early days... when models couldn't be trusted for more than 5% of the code you wrote. Over the last 2 years that's evolved so quickly that I now write nearly 0% of my code by hand, on personal projects and at work. I've used all kinds of tools in that time too. OpenCode, Zed, Claude Code, Codex, Cursor, Windsurf, OpenCLAW, Lovable... and probably a bunch more I can't recall in the haze that's been AI ADHD for me. Over that time, I started with just copy-pasting code between ChatGPT's interface and my IDE almost like a slightly faster Stack Overflow search. Then that somewhat evolved with Cursor quite a bit. I sort of went from prompt engineering to something closer to a human relay pattern. Then, with Plan Mode becoming a thing, I think I naturally gravitated more towards planning everything because planning felt so cheap. Originally, I used to think that architectural discussion and planning was something that was reserved for larger features, but with expediting my ability to do research, orient myself within a codebase, and know what tools I have to reach for doing technical specifications for everything felt reasonable. From the human relay pattern, I started evolving into more autonomy, especially when Claude Code came out earlier last year. Between the combination of Cursor and Claude Code, starting to get orchestration, starting to use skills more heavily, starting to create actual agent personas that could replace some of my common prompt chains it was around then that I kinda started going all in on true context engineering, utilizing sub-agents optimizing cache reads, and it's probably when many of my first (I call it) sophisticated commands were born. All of this converged pretty rapidly in November of 2025 with the release of what was probably the biggest step increase for AI as far as code quality went with Opus 4.5 and Codex 5.3. The Codex app and Codex CLI were quickly growing. Claude Code was improving at a breakneck pace, introducing all kinds of new ways to introduce deterministic gates within the autonomy of the harness. Fast forward to today, I have a pretty sophisticated workflow with a combination of agents that do everything within the SDLC, commands for almost every type of entry point for work, and skills for just about everything I could possibly do in my day-to-day the workflow with some of the latest tools is able to run quite autonomously overnight do large feature implementations, minimally supervised while producing production-worthy code quality It somewhat reached a point I realized, probably a month and a half ago or so where I needed to figure out a way to remove myself even more from the loop without jeopardizing the determinism that I bring to what is effectively a probabilistic LLM. The models are exceptional, and they seem to have a massive step increase each release, but continuous execution, strict instruction rigor, and preventing hallucinations is still very much difficult to achieve. That's predominantly what I've been doing. I've effectively offloaded a lot of thinking to the agents and LLMs that I use, but none of the understanding. I've asked myself, "How do I maintain that understanding, though maintain the determinism from my steering, without actually physically being there to steer?" This was essential, and I realized or had a bit of an aha moment, just like how I manage teams of engineers that are working on numerous projects, most of which I can never really go too deeply on even though they do most of the thinking, most of the building, and even most of the implementation planning, I was still there, very close to the architecture. I could speak to enough breadth and enough depth to keep us out of trouble and keep things moving I kind of started thinking more about what the shape of me was within the agentic harness and how I could replicate that. More on what I landed on a little bit later. My Setup and How I Work Today To start, I'll probably just talk a little bit about my current working setup. I am predominantly in the terminal now a days using Claude Code. Claude Code orchestrates both the Claude models, of course, and I use it to orchestrate Codex through a series of run books, skills, and commands that I have set up on several hooks so that Codex, when it gets dispatched, also has access to the same skills and agent personas Claude does. I use Ghostty as my terminal of choice and use the IDE integration in claude code pretty heavily to review Markdown or HTML files in my IDE. I also use it to review code snippets and diff reviews, although lately I find myself only really looking at the code nowadays once it's hit a merge request. Some of my adjacent tools are Wispr Flow for faster steering, since I can speak a lot faster than I can type and then I use quite a few MCPs and tools to improve my token usage, but the big ones are I have a custom doc maintenance suite of

Some patterns I've landed on for making codebases agent-ready (CLAUDE.md, file structure, naming)

Been using Claude Code on my Android projects for a while. It's been amazing! I've started building on the apps that I'd been thinking of making, but never got the time! But hitting the usage limit irked the hell out of me. The agent would read 600-line files, re-read them across turns, and still occasionally drop changes in the wrong place. The moment it really clicked for me was watching it stuff a new feature into a UserManager class that already handled auth, sessions, profile updates, AND analytics. Not wrong technically. The class touched related concerns. But it's the kind of decision a developer makes when they haven't actually internalised the architecture and just finds the nearest plausible container. Made me realise the agent isn't being lazy. It just shows up cold every time. Like a new hire on day one, repeatedly. No memory of why that class is bloated, why you're avoiding that library, what the team decided three months ago. Anything that lives in someone's head is invisible. So I started giving it rules. A CLAUDE.md at the repo root. Explicit instructions. Keep files small. One class, one job. Create a new file rather than extend an old one. Rough at first, then refined over a few sessions. The change was immediate. Agent stopped producing monoliths, and that pattern of re-reading the same 600-line file three times in one session basically went away. Three things that helped more than I'd have guessed: Negative rules outperform positive ones. "Do NOT touch BaseActivity, it's shared across 12 features and breaks silently" works far better than "follow good design." The agent is optimistic by default and takes the path of least resistance unless you explicitly close it off. Names matter way more than I thought. UserSessionExpiryHandler is a contract. Handler is noise. The agent pattern-matches hard on names, and good ones meaningfully cut how much file-reading it has to do. Each directory gets a README that lists what does NOT belong there. Telling the agent "no business logic in presentation/" prevents more bad calls than "presentation is for UI." Bit counterintuitive, but the negative framing seems to land harder. Anyway, curious what others have landed on. Anyone written a rule that genuinely surprised you with how much it helped? Also wondering if anyone has actually measured token cost before/after structuring a codebase this way. Mine feels like it dropped a fair bit but I never instrumented it properly. Full writeup with the rest of the rules and examples (friend link, no paywall): https://medium.com/gitconnected/your-ai-agent-is-burning-tokens-because-your-codebase-wasnt-built-for-it-ac199beeea32?sk=d7cad9db5fde0219daffa25879cdcf62 submitted by /u/xBlackSwagx [link] [comments]

I built RCFlow: an open-source orchestrator for Claude Code (and Codex/OpenCode)

I've been using Claude Code heavily for the some time already, usually with several sessions running in parallel inside tmux. The pattern that kept breaking me down: I'd kick off 8-10 sessions across different tasks, half would finish, and I'd want to go back, review what they did, do some manual QA, and push them forward. But the important sessions would fade out of my attention. I'd lose track of which window was which, miss the prompts where Claude was waiting on a confirmation (even with sound hooks), and some sessions would just quietly get closed and forgotten. Hooks and plugins help inside one session — but there's a ceiling once you're juggling many of them. So I built RCFlow — an open-source orchestrator for coding agents. It supports Claude Code, Codex, and OpenCode. The idea: one UI where every session is visible, with state. Nothing slips. You stay the developer making decisions — RCFlow just gives you the tooling to drive a lot of sessions in parallel. To be fair: Claude Code has since added /color and /rename, which help a bit with telling sessions apart. They didn't exist when I started RCFlow, and they're useful. But they help you label sessions, not track what each one is working on or what state it's in — that's the gap RCFlow still fills. What it does Machines → Projects → Sessions hierarchy in one sidebar. Status dots tell you what's running, paused, waiting, or done. One client, many workers. A single client connects to backends across all your machines (Linux, macOS, Windows, WSL). Client runs on Linux, macOS, Windows, or Android. Tasks tab — write up the task and description first, then spin up a session from it. Beats starting blind. Prep plan — draft a plan for a feature before the session that implements it. Artifacts tab — RCFlow reads session messages, picks up file paths via regex, surfaces them in one place. I use it for .md files (plans, docs), but you can configure the regex to track anything — built .exe files, logs, generated assets, whatever. Worktrees that actually work. Git worktrees alone aren't enough — a new branch often needs fresh dependencies and env vars too. RCFlow creates the worktree, auto-detects the package manager (npm/yarn/pnpm/bun, pip/poetry/uv/pipenv, cargo, go mod, bundle, dotnet, maven, gradle), runs install, and copies .env by default (configurable per project). Telemetry & analytics — real-time charts for token usage, latency, and tool-call metrics with per-session and aggregate drill-down. Useful for actually seeing where your token budget goes. Live config — change LLM provider, API keys, ports, and other settings at runtime via REST. No restart. Orchestrator LLM — RCFlow runs its own LLM on top of the coding agents — a helper layer you still drive, not an autopilot. Pluggable across Anthropic, AWS Bedrock, or any OpenAI-compatible endpoint. Stack Flutter client, Python 3.12 + FastAPI backend (managed with uv), SQLite (chose it because it runs without a separate service — easy to spin up, easy to wipe, no extra infra to babysit). AGPL v3-licensed. On the license: I went with AGPL v3 because I want RCFlow to stay open for users but not get taken closed-source or repackaged as a paid cloud product. Install (Linux/macOS) curl -fsSL https://rcflow.app/get-worker.sh | sh # backend curl -fsSL https://rcflow.app/get-client.sh | sh # desktop client Pre-built clients for Linux, macOS, Windows, and Android are on the releases page. Latest is v0.43.0. How it talks to Claude Code RCFlow uses each agent's API as much as possible. The APIs do have gaps — for example, Claude Code's API tells you that a file was edited and which file, but not what changed in it. You can see the diff in the terminal but it's not exposed via API, so RCFlow had to work around it to surface diffs in the UI. Honest rough edges Rare but real: occasional message loss in a session if the app crashes or restarts mid-session. Not the whole session — individual messages. The bug that annoys me most. Pausing/resuming sessions has hidden complexity. Sometimes pausing doesn't take effect immediately and the agent keeps working for a bit before actually stopping. Attachments work but are underbaked. Right now they're context-dumped text. I want agents in a session to treat them as real files they can read and copy into place. Haven't had time to make it good yet. Coming next Proper permission management. Right now coding agents mostly just do what they can do without asking — edit this file, run that command. I want RCFlow to surface explicit allow/deny prompts, define what each agent can touch and where, and keep a history of permission decisions so you can audit what was granted and when. I need to do this feature. How it compares I looked at a few similar tools after building it: Conductor is the closest to RCFlow in spirit, but the architecture is different. Conductor is a process manager with a GUI — it spawns Claude Code/Codex instances in worktree

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`,