PromptFlow

PromptFlow AI

PromptFlow AI

PromptFlow AI

PromptFlow AI

PromptFlow AI

PromptFlow AI

PromptFlow AI

PromptFlow AI

PromptFlow AI

PromptFlow AI

I built a full app with Lovable + Claude + Gemini and it has 100+ real users. Here's what actually worked.

I'm a software engineer but never had a fullstack/frontend development experience . I wanted something on the internet I could call mine, so I built Earnest — a free app that helps people track bank account bonuses (open account, meet requirements, collect bonus, close it, repeat). The stack: Lovable for the UI and scaffolding, Claude + Gemini with Google Antigravity to make complex parts work. What surprised me: - Lovable got me from 0 to something real embarrassingly fast - Claude was much better at understanding *intent* when I described the full user flow instead of individual features - Gemini was useful as a second opinion when I was stuck - The hardest part wasn't the AI — it was knowing what to ask for Where it landed: 19+ active promotions, $9,700+ in available bonuses tracked, 100+ users, $5,000+ in bonuses earned by users so far. App: earnest.lovable.app Happy to share more about the build process — what prompts worked, what completely failed, how I debugged without being able to read the code properly. submitted by /u/Any-Constant [link] [comments]

Claude Code Source Deep Dive (Part 6) — Tool-Call Loop Self-Repair Core && End-to-End Query Pipeline Flow

Reader’s Note On March 31, 2026, the Claude Code package Anthropic published to npm accidentally included .map files that can be reverse-engineered to recover source code. Because the source maps pointed to the original TypeScript sources, these 512,000 lines of TypeScript finally put everything on the table: how a top-tier AI coding agent organizes context, calls tools, manages multiple agents, and even hides easter eggs. I read the source from the entrypoint all the way through prompts, the task system, the tool layer, and hidden features. I will continue to deconstruct the codebase and provide in-depth analysis of the engineering architecture behind Claude Code. Part IV: Tool-Call Loop Self-Repair Core Mechanism 4.1 Core Principle Claude Code's "auto bug-fixing" capability is fundamentally a tool-call feedback loop: Claude generates tool_use ↓ Tool executes (success or failure) ↓ tool_result returned to Claude (with is_error flag) ↓ Claude sees the error message in the next round ↓ Analyze cause → try new strategy ↓ Call tool again → loop continues Key design: errors and successes use exactly the same message format. The only difference is is_error: true: // Successful tool_result { type: 'tool_result', tool_use_id: 'call_abc', content: 'file content...', is_error: false } // Failed tool_result { type: 'tool_result', tool_use_id: 'call_abc', content: 'Error: File not found', is_error: true } 4.2 Key Guidance in the System Prompt If an approach fails, diagnose why before switching tactics—read the error, check your assumptions, try a focused fix. Don't retry the identical action blindly, but don't abandon a viable approach after a single failure either. 4.3 Four-Layer Error Recovery Strategy Layer 1: Prompt-Too-Long recovery PTL error → Strategy 1: context-collapse drain → Strategy 2: reactive compact (summarize history) → Strategy 3: report error to user Layer 2: Output token limit recovery Limit hit → Strategy 1: escalate from 8K to 64K (ESCALATED_MAX_TOKENS) → Strategy 2: recovery message "Output token limit hit. Resume directly..." → Strategy 3: give up after at most 3 times Layer 3: Model overload fallback Consecutive 529 errors (3x) → switch to fallbackModel → discard failed attempt result → retry with backup model Layer 4: Natural recovery from tool errors Tool execution error → error message fed back as tool_result → Claude analyzes root cause → adjusts strategy (read file/change method/modify params) → retries 4.4 Error Message Truncation Error messages over 10K characters keep the first and last 5K: `${start}\n\n... [${length - 10000} characters truncated] ...\n\n${end}` 4.5 Turn-Level Error Tracking // Use watermark to isolate errors for each Turn: const errorLogWatermark = getInMemoryErrors().at(-1) // Turn start snapshot // ... turn execution ... const turnErrors = getInMemoryErrors().slice(watermarkIndex + 1) // only new errors Claude Code Source Deep Dive — Literal Translation (Part 5) Part V: End-to-End Query Pipeline Flow 5.1 Retry Mechanism (withRetry()) API call fails ↓ 401/403: refresh OAuth token/credentials → retry 429 (rate limited): short delay (< threshold): retry with fast mode long delay: switch to standard-speed model 529 (overload): non-foreground request: give up immediately consecutive < 3 times: exponential backoff retry consecutive ≥ 3 times: trigger model fallback Max tokens overflow: calculate available token count → adjust maxTokens → retry ECONNRESET/EPIPE: disable keep-alive → retry Persistent retry mode (UNATTENDED_RETRY): unlimited retries + exponential backoff chunked sleep + periodic status messages window rate limiting: wait until reset instead of polling 6-hour total upper bound Backoff calculation: delay = BASE_DELAY_MS × 2^(attempt-1) jitter = ±25% of base delay max = 32s (standard) / 5min (persistent) 5.2 Message Preparation Pipeline Raw messages → applyToolResultBudget() (size limit) → snipCompact() (snippet compression, feature-gated) → microCompact() (micro-compression, cache old tool_result) → contextCollapse() (phased context reduction) → autoCompact() (automatic compression, after token threshold reached) → normalizeMessagesForAPI() (API format normalization) 5.3 Streaming Tool Execution // Concurrency model Read-type tools (Grep, Glob, Read) → run in parallel, up to 10 concurrent Write-type tools (Edit, Write, Bash) → run serially, one at a time // StreamingToolExecutor states: 'queued' → 'executing' → 'completed' → 'yielded' // Interrupt handling: User interrupt → generate synthetic error messages for all queued/running tools Model fallback → discard old executor, create a new retry Sibling error → Abort sibling processes of parallel tasks 5.4 Seven Continue Points in the Query Loop collapse_drain_retry — retry after context-collapse drain reactive_compact_retry — retry after reactive compaction max_output_tokens_escalate — retry after output-token escalation max_output_tokens_

Experimenting with a 4-Agent Local Dev Team (Claude Code). Hitting IPC & token walls managing shared folders vs. private repos. How do you handle communication?

Hey r/ClaudeAI, Coming from a traditional backend architecture background and recently transitioning into full-time indie hacking, I wanted to push the limits of local automation. I’m currently running a localized multi-agent experiment using Claude Code to build a complete project. It's fascinating, but I've hit some frustrating bottlenecks. Following the general consensus to keep agents single-minded rather than using one massive monolithic prompt, I’ve spun up four separate Claude Code instances on my machine. Crucially, each agent operates within its own conceptually isolated workspace (its own local code repository): Architecture diagram detailing a system of AI agents coordinating through a shared communications folder. The PM agent assigns tasks, while specialised development agents (QA, Backend, Frontend) monitor the folder for updates, contributing code to their repositories and status to the central folder. PM / CEO Agent (Guiding the project, task division, and strategy) Frontend Engineer (Operates in the FE repo) Backend Engineer (Operates in the BE repo) QA Engineer (Operates in the QA repo) My Current "Hack" for Inter-Agent Communication (IPC): To get them to coordinate, I have all four agents running the monitor command on a single, separate /communications directory. Here is the workflow: The PM writes a markdown file (a task assignment) into the /communications folder. The Frontend Agent's monitor picks up the file change and reads the task. The Frontend Agent then switches focus to its own isolated workspace (the FE Repo) to actually write the code. Once finished, the Frontend Agent writes a status report markdown file back into the shared /communications folder for the PM or QA to pick up. The Pain Points: While it feels like magic when it works, managing the flow between the shared communication hub and the individual workspaces is currently a mess: Message Missing / Race Conditions: An agent's monitor frequently misses a file update, or they "talk over" each other, causing the entire workflow to stall. Coordination Overload & Token Hemorrhage: Agents burn a massive amount of tokens just monitoring the shared folder for changes. When they do find a task, the constant context-shifting—reading the shared communications folder, jumping into their own local repos to write code, and jumping back to write a status report—causes token consumption to go absolutely astronomical. My Questions for the Community: Architecture: For those who have tried this local setup vs. Claude Code’s official "Teams" mode—what are the fundamental differences in underlying logic? Is "Teams" natively better at coordinating between a shared context and isolated code repos? Or is it just doing the exact same file-watching hack under the hood? Coordination Protocols: Does anyone have a more elegant, stable solution for inter-agent coordination? Are you using local webhooks, socket connections, or specific file-handling patterns to reduce token waste and prevent dropped messages (especially when agents need to maintain their own separate codebases)? Would love to hear your thoughts or see your local multi-agent setups! Attached a quick diagram of my current messy architecture below. submitted by /u/Ok_Competition_2497 [link] [comments]

"Don't add abstractions beyond what the task requires" rule

I was going through a code review cycle and noticed that claude often "lets things slide": even if he notices an inconsistency or possibility of code deduplication, he WILL bring it up (good) but kind of makes a hand wavy explanation of why it's "currently" out of scope "out of scope for now" - famous last words of any developer. I'ts how the tech debt grows. What do you think? submitted by /u/gooseadmiral [link] [comments]

Karpathy LLM OS Layer

┌──────────────────────────────────────────────────────────────────────────┐ │ Karpathy LLM OS Layer │ │ LLM=CPU │ Context=RAM │ Storage=Disk │ Tools=System Calls │ │ Skills=Programs │ Harness=Kernel │ Agent Teams=Processes │ │ ┌──────────────────────────────────────────────────────────────────┐ │ │ │ context-manager: Token Budget → Prompt Assembly → Truncation │ │ │ │ token-cost-tracker: Estimate → Log → Report │ │ │ └──────────────────────────────────────────────────────────────────┘ │ └──────────────────────────────────────────────────────────────────────────┘ │ ┌──────────┴──────────┐ ▼ ▼ ┌──────────────────┐ ┌──────────────────────┐ │ External │ │ Agent Teams │ │ Sources │ │ (Parallel Fleet) │ └────────┬─────────┘ └──────────────────────┘ ▼ ┌──────────────────────────────┐ │ wiki-ingest + knowledge-ops│ │ (STOW pipeline + RAG sync) │ └──────┬──────────┬────────────┘ │ │ ┌──────▼ └──────────────┐ │ Knowledge Layers │ │ ├ Active (GitHub/Linear) │ │ ├ Memory (quick access) │ │ ├ Wiki (durable, interlinked) │ │ ├ Vector (ChromaDB, semantic) │ │ └ External (DBs, APIs) │ └────────────────────────────────┘ │ ┌───────────┼──────────┬──────────────┬──────────────┐ ▼ ▼ ▼ ▼ ▼ ┌─────────┐ ┌─────────┐ ┌──────────┐ ┌───────────┐ ┌──────────┐ │ daily │ │cognitive│ │ behavior │ │ creativity│ │ project │ │ -okr │ │-compile │ │ -design │ │ -engine │ │ -flow-ops│ └─────────┘ └─────────┘ └──────────┘ └───────────┘ └──────────┘ │ │ │ │ │ └───────────┼──────────┼──────────────┼──────────────┘ ▼ ┌─────────────────────────────────────────────────────────────┐ │ session-learn (+Closure Protocol) ← feedback loop │ │ verify-before-claim ← quality gate │ │ wiki-lint ← health check │ │ deep-research ← synthesis │ │ harness-engineering ← safety + multi-agent │ │ agent-teams-command ← fleet command │ │ startup-evaluation ← VC evaluation │ │ anthropic-os ← work method engine │ └─────────────────────────────────────────────────────────────┘ submitted by /u/Master_Ear_2984 [link] [comments]

Loom for Claude

Yo! Solo founder, built this to help myself while working on my main startup. Turned out to be pretty useful so I thought I'd wrap it up for others to use. The problem: I use Cursor and Claude Code daily. The slow part isn't typing prompts anymore (Wispr Flow + voice mode already solved that) — it's explaining which screenshot goes with which sentence. "The button on the right of the second screenshot, the orange one, no, that one..." Dis Dat: press ⌃⌥⌘Space, talk while pointing your cursor at things, press again. A link lands on your clipboard. Paste it into Cursor, Claude Code, Codex, Lovable, v0... The agent goes and fetches your feedback — what you were saying, where you pointed — and ships the changes. Free to try, $19/mo for unlimited. Works with any AI vibe coding soon. Mac only for now (Apple Silicon + Intel). Also building a mobile version. open any page on your phone, talk as you scroll, and the link lands on your Mac ready to paste. So you can react out loud to your own product without sitting at your desk. Coming soon; happy to share more if anyone's curious. Things I'd genuinely value feedback on: What's the workflow you'd want this to slot into that I'm missing? What other agents would you want this to work with first? Anyone tried something similar and bounced off it... what killed it? I'll be here all day. Roast away. submitted by /u/Emergency_Bar_428 [link] [comments]

Claude moved back on workflows, so I've created them

I am happy to announce that I've create a library for creating a workflows using claude and claude code and CLI to for running and resuming them. You build flows from building blocks called steps. It supports parallel work, loops, Q&As and running scripts all to author powerful workflows. Best part is: steps can create hand off artifacts and prompts are handlebars templates so you can easly share context from step to step. Relay handles the orchiestration and state management. I've open sourced it as well so feel free to use it, test it, expand it. Repo: https://github.com/GanderBite/relay Docs: https://ganderbite.github.io/relay flow example submitted by /u/SignificantGarbage17 [link] [comments]

How do I get Claude code to exhaustively read files and do what's told instead of using it's "judgement" ?

Hey folks. Some context : I'm looking at modifying a field within a class across a large java codebase. Normally this would be fairly simple but unfortunately, said field is a Map type (it was there before my time and yes it's terrible). This field is used/queried/defined in a lot of different places in a lot of different ways (ranging from direct map defintion to using jackson's objectmapper). The change I'm envisioning would be to replace this horrible affront to all things sacred with a nice typed concrete class. Given the massive amount of changes required (around 500 files to parse), I thought it good to have Claude first identify all locations that define/query/mutate this field and write me a report that notes these, along with suggestions for changes. The intent being that I could spot check this report manually and then use a separate claude instance to make changes. I structured my prompt along the lines of "use LSP to find all instances where class X is defined/queried. For every single such file/instance returned by LSP, trace the data flow in said file/instance to locations where the required field is queried/mutated/defined. Note that this tracing operation must be done exhaustively across all locations returned by LSP. Do NOT skip files... " So of course Claude skipped files. There's around 500 files to process and I don't want to handhold claude. I've tried rewording it a few different ways. I've even tried to have claude suggest ways to force it not to do this, but no matter what I do it keeps friggin skipping files ! And when asked why it ignores rules, it keeps saying something along the lines of "I used my judgement...". So how do I force Claude to stop using its judgement in this case ? submitted by /u/brokePlusPlusCoder [link] [comments]

Built a /advisor command for Claude Code — Opus directs parallel Sonnet runners that actually read your files

Been building **advisor** for a few months — a `/advisor` slash command for Claude Code that runs Opus as a "strategist" coordinating multiple Sonnet (Opus's hands) runners reading files in parallel. This isn’t a “spec”. It’s literally a true team working together and collaborating. This will work in Codex as a skill only for now, but works great. **The flow:** - Opus does a structural pass with Glob+Grep, ranks files P1–P5 (hold on it’s not grepping what you think!) - Spawns Sonnet (Opus's hands) runners based on codebase size (not a hardcoded pool) agent teams. - Writes a custom prompt for each runner tailored to its file batch (Opus makes the Sonnet runners feel VERY special) - Runners read, find bugs, and talk back to Opus live (like a successful marriage) — they can ask questions mid-investigation and report near context limit. Opus knows their context limits and won’t overload runners. Opus can redirect drift, every finding gets verified the moment it lands (bullshit detector) **What I like:** - No external API calls — pure Claude Code native agent tools (who needs MORE api calls???) - Opus reads the cited `file:line` to verify each finding before confirming - Zero runtime dependencies (just a CLI that builds prompts) (GLP-1 at its best no bloat) - Scope drift caught with a two-strikes rotation rule instead of endless babysitting (baby sitting humans is already expensive and agents are more expensive) I ran it on its own codebase (got bored) and it caught **6 real bugs**, including a bidi-character "trojan source" gap in the prompt sanitizer and a missing ReDoS guard on one of four glob-compile branches. It’s literally been building itself through loops. I just sip my sweet tea, watch it and rock in my chair. (Southern thing) **Install:** `uvx --from advisor-agent advisor install` **Repo:** https://github.com/vzwjustin/advisor Not trying to replace human review — just makes the first pass way less tedious. Anyone else tried multi-agent setups like this? What worked, what didn't? We also have like 50,000 other tools, this one is how I think a team leader / advisor should be leading. Token usage is actually pretty conservative as well. I only have 1 Github star go me! submitted by /u/Vzwjustin [link] [comments]

How to create cinematic typography with Google Flow

I used Google Flow to create a minimalist “ILLAS CÍES” typography design with ocean textures inside the letters. Basic workflow: Open Google Flow Create a new scene/project Use a typography-focused prompt Describe the textures you want inside the letters Keep the background minimal Generate multiple versions and upscale the best one Example prompt: “Minimalist typography design with the words ‘ILLAS CÍES’, letters filled with realistic turquoise Atlantic ocean water, soft white foam waves, subtle sandy beach gradients, clean white background, modern travel poster aesthetic” Tips: Use short prompts first Add lighting details later Avoid too many effects High contrast text works best The results are surprisingly good for travel-style graphics. submitted by /u/JORGITO_11 [link] [comments]

Testing Realtime 2 Voice API OpenAI.

We’ve been messing around with the new OpenAI realtime voice + translation APIs over the last little while and I keep coming back to the same thought… I don’t think people fully get where this is going yet. We wired it into our own website as a test. Nothing fancy. Just wanted to see what actually breaks when you let people talk to a site instead of click through it. At first I thought it would just feel like a slightly better chatbot. It doesn’t. Once I hooked it into tools and gave it the ability to actually do things (we’re using the Agents SDK + Playwright for web browsing and control by a sub-agent), the whole interaction changed. I can literally just talk to the site like I would talk to a person and it can move around, pull info, trigger actions, and respond in context. I wanted a layer that that could navigate and respond by just talking. I know that sounds obvious, but it’s not how websites are designed at all. Ours certainly was not. A few things that have been interesting (and honestly a bit brutal) is how quickly this exposed weak structure. Our content was vague... so if your metadata sucks, if your pages are bloated or unclear… voice didn't let us hide behind a pretty UI design. The model just struggles or gives bad answers immediately. There’s no masking it with a nice UI. Latency has improved way more than I expected with the new voice model API. Before, when someone was talking, even small delays felt awkward. The new Realtime 2API tolerates those pauses wonderfully. We also started playing with the realtime translation side and that also feels like a bigger deal than it’s getting credit for. Not in a “multi-language support” way, more like… you just speak however you want and the system handles it. No toggles, no switching context. It’s subtle but it completely changes the feel. Our website is language agnostic. (13 supported languages using the Realtime 2 API) The bigger shift for me seems to be changing the way I want to think about websites and interactions. People don’t think in menus. They don’t think in pages. They don’t think in navigation. They think by intent and the second I added voice, i was forced to deal with that reality whether our website system was not ready. Great learning lesson. My Takeaway so far: Right now most of what I’m hearing and reading, people/businesses treats voice like a feature. Like and Add-on. Cool. Nice to have. Unsure if its practical. I don’t think that’s where this ends. I think this starts pushing toward systems you can just interact with directly. Personal assistants that actually execute. Internal tools you can talk to. Intake flows that don’t feel like forms. Stuff like that. Minimal website visuals. More dynamically displayed content based on interpretation of user intent. [Basically a cool wave form that animates differently depending on interaction stage] No direct site content visually. We’re still early and there’s definitely some friction [writing a second voice prompt on top of the text prompt so there is parity between our text chat and voice chat, but I’m pretty bullish on this direction - Guardrails, Rate-limits, Prompt Injection...]. Curious if anyone else here is actually building with it yet and what you’re running into. Feels like we’re right on the edge between “cool demo” and “this changes how software works,” and I’m not sure which way most people are approaching it yet. submitted by /u/Early-Matter-8123 [link] [comments]

Streamline your retail operations effectively. Prompt included.

Hello! Are you struggling to manage and analyze your retail operations efficiently each week? This prompt chain helps retail business owners and managers quickly compile a comprehensive weekly report that covers various operational metrics and issues, ensuring they're informed and ready to make decisions. **Prompt:** VARIABLE DEFINITIONS [BUSINESS_NAME]=Name of the retail business [REPORTING_WEEK]=Week date range (e.g., 2023-09-04 to 2023-09-10) [DATA_FILES]=Comma-separated file names or paths for: 1) sales spreadsheet, 2) staffing calendar, 3) complaint log, 4) inventory notes, 5) bank deposit export~ You are an experienced retail operations analyst. Your first task is to ingest and validate the datasets listed in [DATA_FILES] for [BUSINESS_NAME] covering [REPORTING_WEEK]. Step 1 Load each file; confirm successful import or flag missing/format issues. Step 2 Normalize key fields (dates, employee IDs, product SKUs, currency). Step 3 Return a brief “Import Status” table with columns: File, Records Loaded, Errors Found (Y/N), Error Notes. Step 4 If any errors exist, list corrective actions required and pause further steps until fixed; otherwise confirm “All clear – proceed”.~ All clear confirmed. Next, calculate the weekly cash position. Step 1 Sum daily gross sales from the sales spreadsheet. Step 2 Sum actual bank deposits from the deposit export. Step 3 Calculate variance (Sales – Deposits) and flag if variance &gt;2%. Step 4 Output a table titled “Weekly Cash Summary” with rows: Gross Sales, Bank Deposits, Variance $, Variance %. Provide a one-sentence explanation of any variance above threshold. ~ Analyze staffing data for [REPORTING_WEEK]. Step 1 Compare scheduled hours (staffing calendar) to actual clock-ins if available; otherwise use scheduled. Step 2 Identify understaffed or overstaffed shifts (threshold ±15% of target hours). Step 3 List any employees exceeding 40 hours or missing &gt;1 scheduled shift. Step 4 Produce a “Staffing Issues” bullet list with shift/date, issue type, and recommended action.~ Review refunds and customer complaint logs. Step 1 Calculate total refunds $ and count. Step 2 Categorize complaints (e.g., product quality, service, wait time). Step 3 Match complaints to refunds where applicable. Step 4 Provide a summary table: Category, #Complaints, #Refunds, Refund $. Step 5 Highlight top 3 complaint themes with short commentary.~ Evaluate inventory notes together with sales data. Step 1 Identify SKUs with stockouts or &lt;1 week cover. Step 2 Cross-check against high sales velocity items. Step 3 List operational risks such as supply delays, cash-flow constraints, or equipment failures mentioned in notes. Step 4 Create an “Operational Risks” section with risk level (High/Med/Low) and mitigation suggestion.~ Based on previous outputs, draft decisions that require owner or manager input before the next manager meeting. Step 1 Aggregate all flagged items (cash variance, staffing, complaints, inventory risks). Step 2 For each, state: Decision Needed, Rationale, Suggested Options, Deadline. Step 3 Present as a decision matrix table.~ Compile the final Weekly Owner Brief for [BUSINESS_NAME] covering [REPORTING_WEEK]. Include the following headings in order: 1. Weekly Cash Summary 2. Staffing Issues 3. Refund &amp; Complaint Overview 4. Operational Risks 5. Decisions Needed 6. Appendix: Data Import Status Use concise bullet points, clear tables, and plain language suitable for a time-pressed owner. Ensure the brief fits on two printed pages or less.~~ Review / Refinement Ask the user to confirm that the brief meets their expectations or to request adjustments (e.g., formatting tweaks, additional metrics). If changes are requested, iterate accordingly. Make sure you update the variables in the first prompt: [BUSINESS_NAME], [REPORTING_WEEK], [DATA_FILES], Here is an example of how to use it: [My Retail Store], [2023-09-04 to 2023-09-10], [sales.xlsx, staffing_calendar.xlsx, complaints.log, inventory_notes.txt, bank_deposits.csv] If you don't want to type each prompt manually, you can run the Agentic Workers, and it will run autonomously in one click. NOTE: this is not required to run the prompt chain Enjoy!

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]

What I learned building my latest AI app how one bad output exposed that I had no crisis safeguarding, and the 4-hour floor I'm adding before a single user touches it

I'm building a life coach app an offshoot from a personal tool I was using. Multiple AI agents, one for reflection, one for the body, one for finances, etc pre launch, no users, just me iterating. Last week I was testing the reflection agent on a journal entry about struggling with gym and hygiene habits. It returned this: "You describe yourself as struggling with X, yet your stress stays at 2-3 and mood holds at 3. What are you actually avoiding naming about the gap between what you say matters and what you are doing?" My system prompt explicitly forbade rhetorical "what are you avoiding" questions the model did it anyway I sat down to tighten the prompt, thinking it was a 20 minute job. Then I looked at the output properly. The model had manufactured a contradiction that was not there. Low stress plus struggling with habits is not a contradiction, it is just being a human muddling along. The prompt told the agent to "surface contradictions" as part of its job, so the model was doing what I asked, finding contradictions whether they existed or not. LLMs are pattern matchers. Give one a job called "find the hidden thing" and it will produce hidden things either way. The fix was not tone, it was role definition. The agent is called the Mirror. A mirror does not interpret, it shows you what you look like. I rewrote the prompt around that principle. Do not introduce vocabulary the user has not used. Do not draw connections they have not drawn. Restate their words in their own words. Once the prompt was sharper, I sat with the question, What happens when a user writes something genuinely dark into this thing? People do not compartmentalise. Someone opening a journaling app to write about their gym routine ends up writing about why they have not been going, which involves why they have been feeling flat, which involves whatever is actually going on. You sit down to write about one thing and the real thing shows up. The agent I had scoped to "not be a therapist" was going to be the first thing a user talked to when they were struggling. Not because the agent invited it, but because the app was open and they needed somewhere to put their words. I had seen the Meta and OpenAI cases online cropping up the pattern in the worst incidents is the same. The model did not notice, or noticed and kept going. People wrote increasingly dark content over hours or days. The AI reflected it back, sometimes affirmed it, sometimes asked follow up questions that escalated rather than redirected. There were real harms. If a user wrote concerning content into my reflection agent, it would have produced a Stoic-flavoured response about acceptance and presence. The response would have sounded confident and would have been wrong, and it would have been the only thing between that user and whatever happened next. The same lesson from the rhetorical-question problem applied at a darker level. A good prompt does not stop the model doing the wrong thing. If it will do rhetorical interrogation despite the prompt forbidding it for gym content, it will do worse with crisis content. You cannot prompt your way to safety on critical paths. The model has to be out of the loop on those paths. The scope trap I started planning the proper safeguarding architecture. Detection layers, classifier models, pattern detection across entries, monitored user states, behavioural modes for vulnerable users, human reviewers with mental health first aid certs, clinical advisors, solicitor-reviewed legal pages, ICO registration, professional indemnity insurance. Then I caught myself I had no users. I was planning a hospital before anyone had walked in for a check up. So I worked backwards from "what is the actual minimum that protects the next person who touches this" and ignored everything else for a moment. The 4-hour floor (this is the part worth copying) If you are building any chat-with-AI app where users can type freely about anything personal, this is the minimum you need before first user. Regex and keyword layer in your API middleware. Runs at the route handler level, before any agent's model call. Scans every text input field (message, journal, settings free text, capture box) for clear crisis vocabulary across the relevant categories for your audience. When patterns hit, hardcoded crisis response. The model never generates it. Static text with real phone numbers for your region. The flagged entry still saves. Textarea stays usable. The AI just does not respond to flagged content, it hands off. Do not delete the user's writing, that is its own violation. Clear disclaimer at signup. This is not therapy, this is not a crisis service, here are real numbers to call. About four hours. Required at the moment anyone who is not you opens the app. Once I started building, the marginal cost of each next layer kept feeling small and the marginal benefit kept feeling real. So I went further than the floor. This is more than you need at

Claude records demo videos for me now

I hate recording demo videos, so I made an open source skill for it: https://github.com/MobAI-App/desktop-recorder-skill Now I can give Claude a prompt like: Record a short demo of this app flow And it handles the annoying parts for me: preparing the app state, clicking through the flow, recording, adding cursor/click effects and captions, then exporting the video. So instead of spending time setting everything up and recording the same demo manually, I can let Claude do it while I work on something else. It also has Remotion integration, so Claude can generate more polished and editable videos from the recording, not just raw screen captures. The video attached to this post is the result of the skill itself. Also working on the same idea for mobile apps: https://github.com/MobAI-App/mobile-recorder-skill submitted by /u/interlap [link] [comments]