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

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

LLM proxy that lets Claude Code talk to any model

I built rosetta-llm — an open-source multi-format LLM proxy that acts as a drop-in Claude Code gateway. Works as a Claude Code LLM gateway — set `ANTHROPIC_BASE_URL` and all configured models appear in `/model` picker Translates between formats — Anthropic Messages ↔ OpenAI Chat ↔ OpenAI Responses at the wire level Thinking blocks round-trip correctly — this is the hard part and why I built this Provider routing — `openai/gpt-5.4`, `anthropic/claude-opus-4-7`, `groq/llama-4` all through one endpoint Streaming on everything — passthrough fast path + cross-format translation with proper SSE handling The thinking-block problem Most proxies lose reasoning continuity. LiteLLM has had open PRs for thinking block handling for a long time — some dating back months — and they're still not merged. Without proper round-tripping, prompt caching breaks across turns and Claude Code loses context. Rosetta encodes encrypted reasoning into Anthropic's `signature` field and decodes it back — so multi-turn agentic workflows keep their prompt-cache hits. Zero-setup Hugging Face Space Literally a two-line Dockerfile: FROM ghcr.io/lokesh-chimakurthi/rosetta-llm:latest COPY --chown=app:app config.json /app/config.json Add config.json file and above Dockerfile into a HF Space (Docker SDK) and it's running. No clone, no build, no venv. The GHCR image has everything baked in. Make your HF space private and add api keys in hf space secrets. Check readme in github Also works with # No install — ephemeral uvx rosetta-llm # Persistent install uv tool install rosetta-llm rosetta-llm --config ~/.rosetta-llm/config.json # Docker docker run -p 7860:7860 \ -v ~/.rosetta-llm/config.json:/app/config.json \ ghcr.io/lokesh-chimakurthi/rosetta-llm:main Why another proxy? I looked at existing solutions: LiteLLM — thinking block round-trip PRs going nowhere, too many abstractions OpenRouter — great but closed-source, no self-hosting Direct passthrough proxies — don't translate between formats Nothing gave me lossless cross-format translation with proper reasoning fidelity. Links GitHub: https://github.com/Lokesh-Chimakurthi/rosetta-llm PyPI: https://pypi.org/project/rosetta-llm/ Contributions welcome I built this for myself and it works for my use cases. But there's a lot more it could do — better multimodal handling, embeddings support, rate limiting, an admin UI. If any of this sounds interesting, PRs are absolutely welcome. Happy to answer questions in the comments. submitted by /u/DataNebula [link] [comments]

Frontend dev. A month of building a Rust cost tracker + cloud + Cursor extension solo with Claude Code. Honest writeup + workflow tips.

https://preview.redd.it/atpph00rtlxg1.png?width=3318&format=png&auto=webp&s=64332861d25e8833eca6c75a3004d72c9af53769 A month ago I posted about a small CLI I built to figure out where my AI tokens go. Frontend dev, enterprise Claude Code + Cursor sub, didn't pay out of pocket but got curious. That post got way more traction than I expected, so I kept building. A month later, "small CLI" has become: budi — a 6 MB Rust daemon + CLI that tails the JSONL transcripts Claude Code, Codex, Cursor, and Copilot CLI write to disk. Local-only. SQLite. No proxy, no hooks, no network calls. Cloud dashboard (Next.js + Supabase) — opt-in, off by default. Only daily aggregated numbers leave your machine. Prompts, code, file paths — never. Cursor / VS Code extension that mirrors the Claude Code statusline so you see your spend without leaving the editor. Marketing site, CI, Homebrew tap, signed macOS/Linux/Windows binaries. Every layer of this was built with AI. I haven't written a Rust line by hand. Two years ago a frontend dev would not have shipped this solo in a month. The actual unlock isn't the model — it's the workflow The thing that lets one person ship this much with AI isn't "Opus is magic." It's that I built a workflow where the agent always has exactly one well-scoped task in front of it. The pieces that matter: One canonical context file. Claude Code, Codex, and Cursor each want their own (CLAUDE_md, AGENTS_md, .cursorrules). Different agents kept rewriting their own copy and the four files drifted out of sync within a week. Now I keep one canonical SOULmd, and the others are 3-line stub files that just say "Canonical AI-agent repository guidance lives in SOUL.md." Every agent ends up reading the same doc. No drift. Every fix gets a test that fails when the fix is reverted. Unit tests via cargo test --workspace plus 14 bash end-to-end scripts pinned to specific issues. Each script boots the real release binaries against an isolated $HOME and asserts SQLite rows. New scripts have to be negative-path provable — they must fail when the bug they guard is reintroduced. Without this, AI silently regresses things. Strict formatter + lint wall. cargo fmt, clippy -D warnings, Prettier, ESLint on every PR. Non-negotiable. AI agents drift in style across sessions — one writes 80-char lines, the next writes 120 — and without a hard gate the codebase turns into a patchwork in two weeks. Milestones + epic control issues. Each release has a single epic issue listing every sub-task in execution order, with ADRs locking the spec before any code is written. One issue → one branch → one PR. No batched PRs, no long-lived feature branches. A short "Working Rules For The Next Agent" prompt at the top of every epic. "Pick the earliest open issue whose deps are closed, restate goal/risks, smallest change, ship docs with code, one PR per issue." I paste it into a fresh Claude Code session and it just goes. The agent never has to figure out scope, priority, or architecture — those decisions live in the issue body and the ADR. It just picks the next issue and ships the smallest change that closes it. And then budi watches it do that work and tells me which Linear ticket cost $658 in tokens. The tool measures the workflow that built it. Honest take on the tools I rotate between Claude Code, Codex, and Cursor. For building I keep coming back to Claude Code + Opus. Diff quality is better, multi-step refactors across crates hold up, I trust the output more. Codex Desktop has the cleanest "modern agent UI" I've seen — I want Claude Code to steal half of it. Cursor is still my default for inline debugging — model + breakpoints in the same view beats tab-switching. The new claude --chrome mode is a game-changer for web work. Claude Code can drive a real Chrome window — navigate, click, take screenshots, read the DOM, watch network requests, log into the dashboard. I used it constantly debugging the Next.js cloud and the marketing site. No more "describe the bug → describe what I see → describe what I expected" loop; it just opens the page and tells me what's actually broken. This alone made it impossible for me to switch away from Claude Code for the web side of the project. But the code that actually shipped came from Claude Code + Opus, every time. What budi does that I don't think anything else does Cost per ticket. Not per repo, per session, per day — per ticket. budi auto-extracts ticket IDs from your branch names (FE-2308, ENG-123, 42-quick-fix) and tells you "this Linear ticket cost $658 in tokens." Nobody else does this and it's the most useful number I have when I'm trying to figure out which kind of work eats my budget. Plus the usual: cost per repo, branch, model, and file. Live statusline in Claude Code and Cursor (budi · $X 1d · $Y 7d · $Z 30d). Fully offline — the cloud is opt-in, never required. Who I'd love to hear from I built this for me — a developer on an enterprise sub who doesn't pay ou

Built a free Nuzlocke tracker site with Claude as a non-coder — sharing what worked

Hey r/ClaudeAI 👋 I built Nuzlocke Tracker (nuzlocketracker.xyz), a free tool for Pokémon players running Nuzlocke challenges. It's live, 100% free, no signup required, no paywall — just open the link and use it. What it does A Nuzlocke is a self-imposed hardcore Pokémon challenge where fainted Pokémon are considered "dead" and boxed permanently. My site helps players track their runs: log encounters by route, mark Pokémon as alive/dead/boxed, see auto-computed team type weaknesses, and browse game-specific guides. It currently supports 14 Pokémon games (Emerald, FireRed, Platinum, HeartGold/SoulSilver, Black/White, X/Y, Moon, plus ROM hacks like Unbound and Infinite Fusion). How Claude actually helped I have a brand/design background with zero coding experience. Claude wrote every line of code. My workflow looked like this: I described what I wanted in plain language ("I need a page where users can select a game and see all routes pre-loaded, with a form to add encounters") Claude produced complete, deployable HTML/JS/CSS files I uploaded them to GitHub Pages via the web UI and verified the result When something broke, I described the bug to Claude and it fixed it Claude also handled parts I didn't know existed when I started: - Schema structured data (FAQ schema, WebApplication schema) for SEO - Sitemap.xml generation and maintenance - Responsive mobile layouts - Type-matchup calculation logic (the weakness auto-detection) The whole site is 30+ pages across trackers, tier lists, gym leader guides, and rules references. Claude also helped me debug a sneaky issue where my .xyz domain wouldn't accept a sitemap at the root path — we figured out it needed to live in a /sitemap/ subdirectory. That kind of debugging-with-Claude moment happened a lot. What Claude didn't do Claude didn't verify game data accuracy. I still had to cross-check Pokémon stats, move lists, and gym leader teams against Bulbapedia and Serebii. Maybe 1 in 10 data points from the AI needed correction. If you build something data-heavy with Claude, factor in verification time. https://preview.redd.it/p4yvsopmmbxg1.png?width=2538&format=png&auto=webp&s=d75e1952d949b0c6c82834b60efc2e73c870ecc3 https://preview.redd.it/n3etbppmmbxg1.png?width=2550&format=png&auto=webp&s=6001f27381cfe666ed563503dad55c2c3c8be62f Current status The site has been live for about 2 months. Google Search Console shows ~740 impressions and 19 clicks over the last 3 months, with average position around 34. Small numbers, but the trajectory is climbing and that feels like validation that the approach works. Happy to answer questions about the Claude workflow, the SEO setup, or the debugging process if anyone's curious. submitted by /u/Candid_Alps_9494 [link] [comments]