AssemblyAI

AssemblyAI AI

AssemblyAI AI

AssemblyAI AI

AssemblyAI AI

AssemblyAI AI

AssemblyAI AI

AssemblyAI AI

AssemblyAI AI

AssemblyAI AI

AssemblyAI AI

Claude Code helped me bring my dead passion project back to life

**TL;DR: Claude Code took a half-finished HeroMachine conversion and helped me complete it over a long weekend. I'm the creator of HeroMachine, a free Flash-based character creator that's been around since 1998. Over 25 years I and a handful of other artists hand-drew nearly 10,000 items (heads, bodies, weapons, capes, the works) so people could assemble their own superhero illustrations. It found a real audience in tabletop gamers, writers, teachers, kids who just wanted to see their character come to life, and middle-aged dudes like me who once dreamed of a career in comics. At its peak HeroMachine 3 had tens of thousands of active users. Then Flash died in 2020, and HeroMachine died with it. I tried to rebuild. I really did. I hired a developer, spent thousands of dollars, and got back an unfinished product. I tried redoing it myself, but the sheer scope was paralyzing and I just didn't have the energy any more after working my day job every day. HeroMachine 3 has thousands of hand-drawn items across 30+ equipment slots, each with three-channel coloring, transforms, layering, masking, and more. Rebuilding all of that from scratch while also converting every item from Flash's internal format to SVG? I burned out. Real life got in the way. After a while it just felt like I'd failed, and I stopped trying. Fast forward to earlier this year. In my day job as a web developer, I started using Claude Code to automate tedious migration work like taking old WordPress sites and converting their content into our modern custom-built blocks. The kind of work where you know exactly what needs to happen, it's just painfully repetitive. One Friday night I had the thought: "If it can convert old WordPress content, maybe it can help convert those old HeroMachine items, too." Five days later I had a working app. I want to be real about what that means, because I have the same genuine concerns about AI I know a lot of you do. What AI did NOT do: Draw a single item. Every piece of art is still hand-drawn by me and a small group of human artists over the past 25 years. Every creative decision, from what to draw, how to draw it, and what looks right, is still mine. Design the application. HeroMachine's logic — the architecture, feature set, how items and colors and transforms work together — was designed and written by me in ActionScript over 10+ years. Claude Code helped me translate that existing design into a modern stack, but every decision about what the app should do came from me. What AI did do: Help me translate my existing ActionScript code into modern JavaScript and Svelte. I'd point it at the decompiled ActionScript code, explain how something worked, and it would produced the refactored result. Automate the conversion of thousands of Flash-format items into clean SVGs. Help me debug when I got stuck and build new features quickly when I had ideas. Eliminate the parts that were actually stopping me: the tedium, the unfamiliar syntax, the sheer volume of conversion work that made the whole project feel impossible. I got more done in five days than in the previous five years. Not because the AI is smarter than me, but because it removed the wall between "I know exactly what this should be" and "I can actually ship it." I'll be honest, I find AI companies' business practices troubling. I have real concerns about what AI will do to my own industry and my actual job, not to mention the huge data center being built less than an hour from where I live that could have a massive impact on our environment. I hate that it's positioned to take over the fun, creative parts of work while leaving us with the grunt work. Am I sharpening the axe that will ultimately be used on people like me? Maybe. I've sat with that, and I don't have a clean answer. What I can tell you is that I sunk 25 years into HeroMachine and it was dead. Now it lives again, and I have a hard time convincing myself that's an altogether bad thing. HeroMachine 3 "Phoenix Edition" (it rose from the ashes!) is free and live now if you want to check it out. I'm happy to answer questions about the process, the tech, or the ethics of it. I don't think this is a simple story, but at least it's an honest one. submitted by /u/AFDStudios [link] [comments]

Every Markdown File You Write for AI is Already Lying to It

CLAUDE.md files. System prompts. README files with setup instructions. Architecture docs. API references. Runbooks. Onboarding guides. If you've written a markdown file meant for an AI to read, it almost certainly contains values that were true when you wrote them and are no longer true now. The port your dev server runs on. The current version of the package. Which env vars are actually set. How many tests exist. Whether a service is running. These things change constantly, and markdown doesn't know it. So developers do what honest writers do - they add caveats. "Check package.json if this is stale." "Verify before running." "New packages may have been added since this was written." The intent is good. The effect is a list of things the AI has to go verify before it can do anything you actually asked for. We counted them in a real CLAUDE.md. There were seven. And CLAUDE.md is just one file type - the same problem exists everywhere AI reads markdown today. The Pre-Flight Tax Here's a representative CLAUDE.md. Nothing here is invented - these are patterns from real production repos: # CLAUDE.md > Before starting any session: Read ~/projects/api-core/SYNC.md first and check for > pending cross-project items. Update it after completing work. ## Project Overview Acme API - TypeScript REST API. Current version: 1.4.2 (check package.json if this is stale). ## Build and Run Commands # Development (API runs on port 3001, website on port 3000) # Note: PORT is set in .env - verify before running npm run dev:api npm run dev:web # Tests - currently 47 tests across 12 files npm run test:run Before running tests, make sure the test database is not already running on port 27018. Check with: docker ps | grep mongo-test ## Environment Variables | Variable | Required | Notes | |--------------|----------|-----------------------| | DATABASE_URL | YES | MongoDB connection | | JWT_SECRET | YES | Min 32 characters | | PORT | No | Defaults to 3001 | Check .env before assuming anything is configured. ## Architecture npm workspaces monorepo. Packages: - packages/api/ - packages/web/ - packages/shared/ - packages/db/ When in doubt about file counts or structure, run ls packages/ to check - new packages may have been added since this was written. ## Docker Check docker ps to see if a test container is still running from a previous session before starting a new build. Before Claude touches a single line of code, it has to: Open ~/projects/api-core/SYNC.md - cross-project lookup Read package.json - version check Read .env - port verification Check all env var statuses - is DATABASE_URL actually set? Run npm run test:run - or trust a number that's probably wrong Run docker ps | grep mongo-test - pre-test check Run ls packages/ - structure verification Seven tool calls. Each one costs a couple of seconds of latency. The test run alone can take ten. Add it up and Claude spends close to half a minute just getting to the starting line - consuming context and generating output before the actual task begins. And that's the obvious tax. The hidden one is subtler: every one of those checks can generate a follow-up. The .env read reveals WEBHOOK_SECRET isn't set. Now Claude has to decide whether to flag it or proceed. The docker ps shows a leftover container. Now Claude has to clean it up. Each verification spawns decisions, and each decision costs more context. The Same File, Rewritten MarkdownAI is a superset of Markdown. Any .md file that starts with @markdownai becomes live - directives resolve at render time, before Claude ever sees the file. Here's what the same CLAUDE.md looks like rewritten: @markdownai v1.0 @prompt role="context" This document is live. Every value was resolved at render time. Do not look up package.json, .env, or docker ps - current values are already below. @end # CLAUDE.md > Before starting: sync status is live in the Cross-Project Sync section below. ## Project Overview Acme API - version {{ read ./package.json path="version" }}. ## Build and Run Commands API on port {{ read .env key="PORT" fallback="3001" }}, web on {{ read .env key="WEB_PORT" fallback="3000" }}. @list ./package.json path="scripts" mode="entries" columns="key:Command,value:Runs" as="table" Test suite (live): @query "npm run test:run -- --reporter=verbose 2>&1 | tail -3" @cache session Mongo test container: @query "docker ps --format '{{.Names}} {{.Status}}' | grep mongo-test || echo 'not running - port 27018 is clear'" @cache session ## Environment Variables @if file.exists ".env" | Variable | Required | Status | |--------------|----------|-------------------------------------------------------------| | DATABASE_URL | YES | {{ env.DATABASE_URL != "" ? "set" : "MISSING - will not start" }} | | JWT_SECRET | YES | {{ env.JWT_SECRET != "" ? "set" : "MISSING - auth will fail" }} | | NODE_ENV | No | {{ env.NODE_ENV fallback="development" }} | @else **WARNING: No .env file found. App will not start.** @endif ## Architecture @list ./p

I'm Building a Fully-Automated AI-Animated Video Show with Claude

TL;DR: I'm building a pipeline that takes a real prediction market bet from Polymarket or Kalshi (like "Will the U.S. confirm aliens exist?"), writes a script for my two AI characters (who argue about its merits like they're the Siskel and Ebert of prediction markets), generates their voices and talking-head video, creates animated B-roll and text cards, and composites it into an approximately 60-second episode meant for social. All vibecoded with Claude. Cost: ~$2.50 per episode. Some example outputs: Will Jesus Christ return by 2027?https://www.youtube.com/shorts/xMep6S5a7z4 Will the US Government confirm aliens exist? https://youtube.com/shorts/FFU20auHijQ Will Trump buy at least part of Greenland? https://youtube.com/shorts/m8uynMUisF8 Who will be the next James Bond? https://youtube.com/shorts/wmwLvjcz-eI These are all real money bets, if you can believe that. The Show The Sal & Eddie Show. Two characters argue about one prediction market bet per episode. Sal is the handicapper — reads odds like a racing form, names the price, tells you where the smart money is. Eddie is the philosopher and can't believe these markets exist, finds the sublime in the ridiculous. They argue for 60 seconds, vertical format, ready for social. The whole thing runs on my NAS (which is mainly my Plex server) in Docker. 100% automated from choosing the bet to final video output. What Happens When I Push the Button Market Pull (Polymarket/Kalshi APIs) → Editorial Scoring — is it an interesting market? (Claude Sonnet) → Script Generation (5 recursive Claude Opus calls) → Emotion Casting to select character images (1 Opus call) → Visual Creative Direction of script (3 Opus calls) → Dialog recording (5 ElevenLabs calls with word-level timestamps) → Talking Head videos (5 Hedra Character-3 calls) → Visual Asset creation (GPT Image 2 → Veo 3 Fast, also via Hedra API) → Edit Assembly (1 Opus call + Python post-processor) → Final Composite — picture, overlays, captions, subtitles (FFmpeg) Production time: ~15 minutes from pressing the button to final cut, fully automated. Cost: ~$2.50/episode — 90% of that is Hedra credits for talking heads and animation. The 8+ Claude Opus calls that drive every creative decision cost about 15 cents total. ElevenLabs TTS is a nickel. What's Working Recursive script generation. Each "turn" gets its own Opus call with full conversation history. Eddie's reaction to Sal is a "real" reaction, not a pre-planned exchange. Two system prompts with full character bibles for better voice separation. Emotion casting as a blind pass. After scripts are locked, a separate Opus call reads the dialogue with character names stripped and assigns emotional postures from a constrained menu, which selects the correct "emotional pose" to use for Hedra character generation for each turn. Sequential visual creative calls. This produces the inset cutaways — three calls, each seeing previous output: main animation, second animation (sees script + hero), fill-in animation (sees everything). Sequential constraints prevent all three visuals from depicting the same thing. The split between LLM & Python decisions. This was my biggest recent lesson. I had an Opus prompt for edit assembly (placing overlays on the timeline) that kept failing — dead stretches, stacked animations, missing coverage. Every prompt fix pushed something else out of working memory. The fix: let Opus make creative decisions (what text cards to write, where to anchor visuals) and let Python handle mechanical rules (every turn needs an overlay, no back-to-back video assets). Same constraints, but the mechanical ones are deterministic code, not prompt instructions. Still WIP Making the insets funnier. The visual style produces gorgeous editorial illustrations but not always comedy. When the style was more cartoonish, the animations landed as jokes. There's an ongoing tension between visual quality and comedic tone. Overall episode timing. Some turns still run 8-10 seconds of pure talking head before a visual appears. Getting better but not solved. Figuring out what to do with this. Maybe it's a daily video show. Maybe it's an app that lets you get Sal and Eddie to argue over anything you want them to. I already have them giving me a daily briefing on what comics I should and shouldn't buy on eBay. Happy to answer questions about any part of the architecture, but the important thing: I am not a coder at all. This whole thing is vibe-coded with Claude. Built with Claude Opus 4 (creative), Claude Sonnet 4 (editorial), ElevenLabs (TTS), Hedra Character-3 (talking heads), GPT Image 2 (stills), Veo 3 Fast (animation), Grok Video I2V (cinemagraphs), FFmpeg (assembly). Running on a Synology NAS in Docker. submitted by /u/Campfire_Steve [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]

the gamma connector + claude projects is the investor update workflow i wish i had 18 months ago.

run a saas for indian tutors. $12K mrr. send monthly investor updates. used to dread the process. assemble data from 4 sources, write the narrative, format a deck, send. current workflow using claude projects + gamma connector: step 1: my "investor relations" project in claude has all my previous updates, investor preferences, and financial data format. no context-setting needed. step 2: paste this month's numbers into the conversation. ask claude to draft the update in the format investors preferred last time. claude already knows the format because the previous updates are in the project knowledge. step 3: trigger gamma connector. claude sends the narrative to gamma. gamma generates a 4-slide visual deck. i review in gamma's editor. minor adjustments. step 4: send the gamma link in a short email. total time: about 12 minutes. down from the 25 minutes i was spending 6 months ago, which was already down from the 3 hours i was spending a year ago before using any AI. the compound effect: each month's update is better than the last because claude references previous updates and my investors' feedback patterns. the third time the system generates an update, the output already anticipates what questions the investors will ask based on the data trends. investor response rate on the new workflow: above 70%. on the old google doc format it was 0% for over a year. the integration between projects (persistent context) and connectors (output to external tools) is the thing that makes claude feel like an operating system instead of a chatbot. for anyone doing regular reporting or updates: the project + connector combination is worth setting up. the setup takes 30 minutes. the monthly time savings compound. submitted by /u/Unique-Affect-6135 [link] [comments]

We built a free tool that generates a DESIGN.md from any live URL, keeps AI coding agents on-brand

The Google Labs DESIGN.md spec launched last month, it's a machine-readable markdown file your AI coding agent reads to understand your design system. This tool automates creating it. Paste any public URL: the tool extracts CSS variables, typography, Tailwind classes, and component patterns, then an AI assembles them into a spec-compliant DESIGN.md. Visual editor lets you fine-tune tokens before you download. Drop the file in your repo root and your agent has a consistent design reference across every session. Works with Cursor, Claude Code, GitHub Copilot, Aider, and Continue. Free, no signup. https://www.masumi.network/tools/design-md https://reddit.com/link/1tb2tki/video/tlqzrvm1sp0h1/player submitted by /u/thinkgrowcrypto [link] [comments]

Love Claude auto-fill giving itself praise

100% misread it the first time as “both look good, keep it up” submitted by /u/OsbornHunter [link] [comments]

I created an agentic orchestration pipeline for music video generation

I’ve been building Uisato Studio, a workflow-based AI creation platform for audiovisual work. This is the Music Video mode: upload an image + audio, and the system analyzes the input, generates visual direction, creates clips, handles b-roll / lip-sync when needed, and assembles everything into a finished music video through a guided pipeline. I’m trying to move AI video from isolated generation into orchestration; an agentic production system built for more coherent, edit-ready audiovisual output. I’ve been building this suite for the past year, hope you guys enjoy it: https://uisato.studio/ submitted by /u/santi_0608 [link] [comments]

5 enterprise AI agent swarms (Lemonade, CrowdStrike, Siemens) reverse-engineered into runnable browser templates.

Hey everyone, There is a massive disconnect right now between what indie devs are building with AI (mostly simple customer support chatbots) and what enterprise companies are actually deploying in production (complex, multi-agent swarms). I wanted to bridge this gap, so I spent the last few weeks analyzing case studies from massive tech companies to understand their multi-agent routing logic. Then, I recreated their architectures as runnable visual node-graphs inside agentswarms.fyi (an in-browser agent sandbox I’ve been building). If you want to see how the big players orchestrate agents without having to write 1,000 lines of Python, I just published 5 new industry templates you can run in your browser right now: 1. 🛡️ Insurance: Auto-Claims FNOL Triage Swarm Inspired by: Lemonade’s AI Jim, Tractable AI (Tokio Marine), and Zurich GenAI Claims. The Architecture: A multimodal swarm where a Vision Agent assesses uploaded images of car damage, a Policy Agent cross-references the user's coverage database, and a Fraud-Detection Agent flags inconsistencies before routing to a human adjuster. 2. ⚙️ Manufacturing: Quality / Root-Cause Analysis Swarm Inspired by: Siemens Industrial Copilot, BMW iFactory, Foxconn-NVIDIA Omniverse. The Architecture: A sensor-data ingest node triggers a diagnostic swarm. One agent pulls historical maintenance logs via RAG, while a SQL Agent queries the parts database to identify failure patterns on the assembly line. 3. 🔒 Cybersecurity: SOC Alert Triage & Response Inspired by: Microsoft Security Copilot, CrowdStrike Charlotte AI, Google Sec-Gemini. The Architecture: The ultimate high-speed parallel routing swarm. When an anomaly is detected, specialized sub-agents simultaneously investigate IP reputation, analyze the malicious payload, and draft an incident response ticket for the human SOC analyst to approve. 4. 📚 Education: Adaptive Socratic Tutor & Auto-Grader Inspired by: Khan Academy Khanmigo, Duolingo Max, Carnegie Learning LiveHint. The Architecture: A strict "No-Direct-Answers" routing loop. The Student Agent interacts with the user, but its output is constantly evaluated by a hidden "Pedagogy Agent" that ensures the AI is guiding the student to the answer via Socratic questioning rather than just giving away the solution. 5. 📦 Retail/E-commerce: Returns & Reverse-Logistics Swarm Inspired by: Walmart Sparky, Mercado Libre, Shopify Sidekick. The Architecture: A logistics orchestration loop that analyzes a customer return request, checks inventory levels in real-time, determines if the item should be restocked or liquidated (based on shipping costs vs. item value), and autonomously issues the refund. How to play with them: You don't need to spin up Docker containers or wrangle API keys to test these architectures. You can load any of these 5 templates directly into the visual canvas, see how the data flows between the specialized nodes, and try to break the routing logic yourself. Link: https://agentswarms.fyi/templates submitted by /u/Outside-Risk-8912 [link] [comments]

My setup for running Claude Code across the full software dev lifecycle

Spent the last several months using Claude Code well beyond the editor: as the reasoning engine inside a multi-layer system that handles tickets, cross-repo implementation, code review, MRs, and a persistent knowledge layer between sessions. Wrote up the architecture, the failure modes, and the lessons. A quick framing note that probably matters more on this sub than elsewhere: when I say "the agent" I mean Claude Code as a runtime (LLM with tool use, file system access, multi-turn loop), not a single API call. So when the orchestrator "hands off to Claude Code," it's transferring control to an autonomous process that may read dozens of files, write code, run commands, and iterate before returning. The single most consequential decision in the whole system: keep Claude Code out of orchestration. Plain Python handles the mechanical work (Jira API calls, git operations, test runs, lint, file moves). Claude Code only gets invoked for judgment: writing code, evaluating a review finding, choosing between two architectural options. Mixing the two, letting the agent orchestrate via tool use, is what made the first version slow, expensive, and non-deterministic. Concretely, the lifecycle of one ticket: Python orchestrator: pull the Jira ticket, search the local wiki for related architectural decisions, set up a worktree on a fresh branch, assemble a 30 to 50 line implementation brief (acceptance criteria, target files, callers of any modified shared functions, relevant standards). Output is a JSON bundle. Claude Code: reads the brief and writes the code. This is the only step with significant token consumption. Python + a separate review subagent: run tests, lint, format. If anything fails, hand it back to the implementation agent (max 3 retries). Then dispatch a code-review subagent configured with no Edit or Write permissions; it can only read and report findings. Python: create a proposal in a dashboard. I approve manually. Then the orchestrator pushes and creates the MR. A few Claude-Code-specific things that ended up mattering: - Subagent isolation. The review agent runs in its own context window with a deny-list (Edit, Write). Splitting review and implementation into two isolated contexts caught a class of issues the implementation agent kept missing on its own, especially behavioral changes in shared code. - Pre-assembled briefs beat dynamic exploration. Early on I let Claude Code explore the codebase before implementing. That worked, but ate noticeably more tokens than handing it a focused brief assembled by Python upfront (Jira fetch, wiki search, dependency analysis). - Skill/command routing via YAML rather than letting the agent decide. The mapping from /ticket, /review, /standup etc. to orchestrators is explicit, so capabilities are inspectable instead of emergent. - Hooks gate commits. A pre-commit hook runs lint and format before any commit Claude Code attempts. Violations block the commit; the agent has to fix them. The wiki layer is what surprised me most. Markdown pages with three confidence tiers (verified, inferred, human-provided) and field-level staleness thresholds. The biggest unlock was the confidence tiering. Without it, agents end up treating their own past inferences as truth and compound hallucinations into authoritative-looking knowledge. Things I'm still wrestling with: - Cross-repo features. Even with structured change-set tracking, the agent loses coherence when a feature spans services. - Vague tickets. The agent produces reasonable but often wrong implementations from ambiguous specs. I now flag ambiguous tickets as blockers rather than letting it guess. - Scope creep. The over-engineering instinct is real. Constant calibration via standards and the review agent. - Long sessions. Earlier context falls out of effective attention. Session-start re-initialization mitigates but doesn't eliminate it. Full writeup with the architecture diagram, the proposal/governance protocol, and the failure case that taught me the most: https://pixari.dev/ai-assisted-product-engineering/ Curious what other people running Claude Code at this scope have settled on. Do you let the agent orchestrate, or have you pushed it to a pure-judgment role too? What permissions setup are you using for sub-roles like reviewer vs implementer? submitted by /u/Alternative_One_4804 [link] [comments]

Don't Believe the Marketing

I've been meandering around the AI domain for a few decades. But I've decided to re-engage - mostly due to the development of the Model Context Protocol (MCP). I am wondering whether anyone else might be interested in engaging in a conversation regarding the current definition (and exploitation) of direct AI actions into our infrastructure. Here is the article I assembled on what I've done in the last week. I wonder if others have similar experiences. https://thebatsignal.substack.com/p/dont-believe-the-marketing submitted by /u/cyclingroo [link] [comments]

Built a Chrome extension for the long-session degradation problem — want this sub's read on whether it's actually useful

Long-time Claude user, finally built something for the long-session problem and want this sub's read on whether it's actually useful or solving something I made up. The pattern that pushed me to build: 60+ messages into a Claude session, the model starts losing the thread. A constraint I set 40 messages back stops being respected. Re-state it, works for two replies, then forgets again. Eventually you hit compaction, panic, summarize, paste into a new chat, and lose half your context anyway. It's not a window-size problem either. Even at 200K (or 1M on the API), usable performance drops well before the limit. The model technically remembers everything, it just stops weighting it properly. What's already out there, since this sub will rightly ask: - Cross-session memory tools (Mem0, MemoryPlugin) — they remember who you are across chats. Different problem. They don't help when this specific conversation is degrading in front of you. - Context indicators (Context Compass, TokenFlow) — they show how full the window is. Useful, but stop at the warning. You still manually summarize and paste. - Claude's own auto-summary — server-side and opaque. You can't see what got kept or trigger it on your terms. The gap I'm trying to close is the workflow between "I see I'm running out of context" and "I'm continuing in a fresh chat without losing the thread." Built it as a Chrome extension called Curlo: - Ring on the chat bar shows window fill, so compaction doesn't ambush you - One-tap checkpoint fires a structured prompt and saves Claude's reply locally — decisions, progress, open questions, next steps. Paste into a fresh chat to keep going - Each checkpoint is a delta against the last, so they stay tight - Fully client-side, no backend, no accounts, free Next up: optional Notion sync (your workspace, your pages, not locked in my tool) and a Prompt Studio that uses on-device AI to assemble prompts from your saved library. https://curlo-pavilion.lovable.app What I actually want from this post: For Pro and Max users — does Projects' shared context meaningfully delay degradation, or do you still hit the wall mid-conversation? Trying to figure out where my tool helps vs where Anthropic already has you covered. What's your trigger for "time to start fresh"? I default around 70% but it feels arbitrary. Anyone using a system prompt phrasing that genuinely delays drift? Would rather steal a workflow than build around the problem. Roast it. submitted by /u/theRedHood_07 [link] [comments]

I spent years building a 103B-token Usenet corpus (1980–2013) and finally documented it [P]

For the past several years I've been quietly assembling and processing what I believe is one of the larger privately held pretraining corpora around... a complete Usenet archive spanning 1980 to 2013. Here's what it ended up being: 103.1 billion tokens (cl100k_base) 408 million posts across 9 newsgroup hierarchies 18,347 newsgroups covered 33 years of continuous coverage The processing pipeline included full deduplication, binary removal (alt.binaries.* excluded at the hierarchy level before record-level cleaning), quoted text handling, email address redaction via pattern matching and SHA-256 hashing of Message-IDs, and conversion from raw MBOX archives to gzip-compressed JSONL. Language detection was run on every record using Meta's fasttext LID-176. The corpus is 96.6% English with meaningful representation from 100+ other languages — the soc.culture.* groups in particular have high non-English density. The thing I find most interesting about this dataset from a training perspective is the temporal arc. Volume is sparse pre-1986, grows steadily through the early 90s, peaks around 1999–2000, then declines as Usenet gets displaced by forums and social media. That's a 33-year window of language evolution baked into a single coherent corpus — before SEO, before engagement optimization, before AI-generated content existed. I've published a full data card, cleaning methodology, and representative samples (5K posts per hierarchy + combined sets) on Hugging Face: https://huggingface.co/datasets/OwnedByDanes/Usenet-Corpus-1980-2013 Happy to answer questions about the processing pipeline or the data itself. submitted by /u/OwnerByDane [link] [comments]

Introducing the Voice Agent API. One WebSocket. Stream audio in, get audio back. We handle the full voice stack so you can focus on your product. Powered by Universal-3 Pro, our speech model built f

Introducing the Voice Agent API. One WebSocket. Stream audio in, get audio back. We handle the full voice stack so you can focus on your product. Powered by Universal-3 Pro, our speech model built for real-world audio. $4.50/hr. No SDK. Ship today → https://t.co/ZQn5aQJe7N https://t.co/pDdzvAttws

I trust Sonnet as my daily driver now — better code, one-third the tokens. Here's how.

For months I defaulted to Opus for anything complex. Sonnet felt like a gamble, sometimes great, sometimes it would confidently build the wrong thing and I'd spend an hour unwinding it. So I'd reach for Opus, burn tokens, and still end up debugging things that should have been caught earlier. When 4.7 dropped my usage spiked and I was forced to take a closer look at my development workflow. Last week result: 30% of my monthly budget consumed and roughly 3x the shipped work compared to the previous week at 73% by the same time (I do my personal dev work on weekends). Code was cleaner. Barely any rework. Sonnet the entire time. I can't give you a controlled study — this is one person, one week, real production work (Cloudflare Workers + TypeScript). But the specific thing that changed was the structure around the model, not the model itself. What changed: FRAGUA I built a four-phase protocol I'm calling FRAGUA (Spanish for forge). It's two skills — CRITICON and MANAYER — run in a specific order: Plan → CRITICON → MANAYER → CRITICON Step 1: Write a plan in markdown. File map, what changes, data flow, known pitfalls. 15 minutes. This sounds obvious but most people (including me, before) skip it or write it too vague to be useful. *Step 2: CRITICON on the plan. Spawn Claude Opus as a named subagent with one job: find what's wrong with the plan. It returns a verdict — SHIPPABLE or NEEDS REVISION — with findings sorted 🔴 Critical / 🟡 Important / 🟢 Minor. You fix the Criticals, send the revised plan back to the *same named subagent instance (it retains context between calls and zooms into what's left rather than starting cold). 2-3 rounds until nothing critical remains. Step 3: MANAYER. Three isolated roles. Coder agent builds from the approved plan — clean context window, no conversation history, just the spec. Reviewer agent audits the output. You apply the CRITICAL/HIGH fixes yourself. Each agent starts fresh. No compounding context. Step 4: CRITICON on the implementation. Same iterative Opus loop, now on the actual changed code. This catches what a single-pass reviewer misses: race conditions, resource leaks on error paths, edge cases that only surface under load. When NOT to use FRAGUA Single-file edits, config changes, quick fixes, exploratory prototyping, research spikes — skip it entirely and just build. The overhead (~45-60 min of structured review) only pays off when correctness matters more than speed and the build touches 3+ files. If you'd throw it away tomorrow, don't FRAGUA it. What actually forced this I was running Opus 4.6 as my default. Opus 4.7 dropped and I hit 70% of my monthly budget in a single day. That forced a question I should have asked earlier: is the problem the model, or is the problem how I'm using it? The answer was the process. Every new model generation will be more capable and more expensive. If your workflow requires the best available model just to function, you're on a treadmill. The answer isn't "wait for prices to fall." It's "stop needing the most expensive model for every task." The uncomfortable part: defaulting to Opus was a symptom of bad process. I wasn't trusting Sonnet because my context was a mess, exploration, design, implementation, and debugging all tangled in one long thread. That's a genuinely hard job. Of course Opus handled it better. Of course Sonnet stumbled. The fix was spec before build, separation of concerns, design review, code review. Software engineering principles from the 1970s, applied to AI assistants. The cost of CRITICON itself The honest question: "Aren't you just moving Opus from the build phase to the review phase?" Partially, yes. CRITICON runs 2-3 Opus rounds before the build and 2-3 after. That's roughly 30-50k Opus tokens per phase. It's not free. The math works because of what it eliminates. When CRITICON catches a design flaw in the plan, that's a whole multi-agent build that doesn't happen. When it catches a runtime bug in the implementation, that's a debugging spiral that doesn't start. The most expensive token in AI development is the one you spend re-explaining context to fix something that should have been caught earlier. On the week I measured: the two main CRITICON sessions cost roughly the equivalent of one hour of unfocused Opus usage. They prevented approximately three hours of rework I can specifically identify — one FK ordering bug that would have been a 5-round debugging session, one API assumption that would have required rebuilding a module. Why Sonnet works inside FRAGUA By the time Sonnet (as the coder) sees the task, Opus has already validated the design across multiple rounds. The plan is airtight. Sonnet doesn't need to reason about architecture — it executes a precise spec. That's what it's actually good at. Sonnet executing a CRITICON-approved plan consistently outperforms Opus winging it from a vague prompt. And costs a fraction. Prior art, what I looked at first Ralph Loop, a