Vercel AI SDK

Vercel AI SDK AI

Vercel AI SDK AI

Vercel AI SDK AI

Vercel AI SDK AI

Vercel AI SDK AI

Vercel AI SDK AI

Vercel AI SDK AI

Vercel AI SDK AI

Vercel AI SDK AI

Vercel AI SDK AI

Claude makes documents into apps

# Any document can become an app I’ve been working on an open-source document format and viewer called **Adaptive Markdown**. The basic idea is simple: A document should not have to stay static. It should be something a coding agent can extend, reshape, and turn into an interactive workspace. This is not just a canvas you edit with a chatbot. The bigger idea is that the document becomes both: 1. the source of truth 2. the programmable interface In other words, the document becomes a living app. You write notes, collect data, draft text, or import files. Then a coding agent can directly modify the document surface: add charts, create calculators, build filters, restyle sections, generate summaries, export views, or turn rough notes into an interactive tool. So instead of having: * a document * a spreadsheet * a dashboard * an app * a changelog * a separate AI chat about all of it You can have one living `.md` file that contains those layers together. # Example A fitness log might start as a plain Markdown journal. Then the agent adds charts. Then it pulls in device data. Then it adds weekly summaries, rolling averages, goal tracking, export options, and a dashboard view. The document did not move into an app. The document became the app. # Other use cases * A billable time log that computes subtotals and rewrites rough notes into polished narratives * A research notebook with experiment parameters, runnable code, outputs, and methodology notes * A recipe book that scales servings and generates shopping lists * A math textbook that can explain a theorem at different levels * A project README that explains the system, demonstrates the system, and lets the agent modify it from inside the document * A small data report with embedded CSV data, live charts, filters, and exportable views The thing I’m most interested in is not "Can Markdown support more widgets?" It is: **What happens when the document itself becomes the programmable, agent-editable interface?** # Demos I made a few short video demos: * Turn your document into a snake game: [https://youtu.be/l-I2UiZd-Jw](https://youtu.be/l-I2UiZd-Jw) * Basic Adaptive Markdown features: [https://youtu.be/cLdzvZAL96I](https://youtu.be/cLdzvZAL96I) * Import CSV, create tables, edit and format them: [https://youtu.be/XKh9D3BlTCg](https://youtu.be/XKh9D3BlTCg) * Import MusicXML and transpose sheet music: [https://youtu.be/8YV3zjMLvA8](https://youtu.be/8YV3zjMLvA8) # Why I’m excited about this The biggest use case I’m excited about is academic and technical reading. In a few years, I don’t think people will just read papers passively. I think they’ll translate passages, ask questions, generate examples, explore alternate proofs, run code, attach notes, convert math to Lean where possible, and keep all of that inside the document instead of scattered across chats and notebooks. This is already pretty natural inside a browser when a coding agent has access to JS, CSS, and the document structure. It’s very early, but the workflow already feels useful to me. I’m using it for my own notes and documents. Right now it is configured for the Anthropic coding-agent SDK and experimentally for Codex. The longer-term goal is to make it run entirely locally. GitHub: [https://github.com/SemiSimpleMath/Adaptive-Markdown](https://github.com/SemiSimpleMath/Adaptive-Markdown) I recently added per-document skills, so agents can automatically know how to style or transform the text or data inside a specific document. Curious whether this seems useful to anyone else, or whether I’m just overexcited because I built it. Feature requests welcome.

AI quietly turned HTML into a real alternative to PowerPoint and Word for client-facing docs. The blockers that made it impractical a year ago are falling one by one.

A year ago, generating a polished document as HTML instead of a PPT or a Word file was a fun idea with too many practical problems. Lately I've noticed every one of those blockers either gone or close to gone, and I've quietly stopped reaching for Office on a bunch of deliverables. Curious if others are seeing the same. **The blockers, and where they stand now:** **Design**. The old objection was "AI HTML looks generic and amateur." That's basically solved if you give the model a design skill or a style guideline once. You get consistent, on-brand output that looks more like a designed page than a default template, every time, without redoing it. **Hosting.** The first wall: a .html file on your machine isn't shareable, and turning it into a URL used to mean GitHub Pages, a Vercel/Netlify deploy, or a bucket setup, all overkill for a single document you just want to send. That's now a paste-and-get-a-link affair, no build step, no config. **Sharing.** The real killer: even with a URL, getting it in front of a non-technical person was a nightmare. A raw .html "won't open," looks broken on their phone, or lands in spam. Screenshotting kills the interactivity, which was the whole point. That gap is now filled by hosted links that just open in a browser like any page. **Security.** "I can't put confidential work on a public URL" used to end the conversation. Access-controlled links (password or email-gated, not public/indexable) handle that now. **Tracking.** With a PPT or PDF you send it and hope. The thing I didn't expect to care about but now can't live without: knowing whether the client actually opened it, and roughly how long they spent. That alone changed how I follow up. Where Office / Markdown still wins, to be fair: anything that lives in version control with clean diffs and line-by-line review, real-time co-editing, and Figma-style pinned feedback on specific elements. Those aren't cleanly solved for plain HTML yet. So I'm not saying Office is dead, more that for one-shot, client-facing deliverables (reports, dashboards, proposals, one-pagers) HTML has quietly become the better option for me. **Two questions for anyone who's made the switch:** 1. Which deliverables did you move from PPT/Word to HTML, and which did you keep in Office? 2. For the ones you moved, what finally made it practical, design, hosting, sharing, something else?

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.

We built a managed memory API for AI agents (open-source SDK + AGM-style belief revision for handling contradictions)

Hey all! We just launched a managed memory API for conversational AI, letting developers add long-term memory to their agents with a single HTTP call. It's built on our in-house xmem SDK, which automatically extracts facts, episodes, and artifacts from multi-turn conversations and handles contradictions and updates through an AGM-style belief revision mechanism. When a user changes a preference or corrects an earlier statement, old memories get automatically flagged as "superseded" instead of piling up as noise. At query time, you can also walk the supersede chain to trace the full version history of any memory. Under the hood, PostgreSQL + pgvector (with HNSW indexing) delivers millisecond-level semantic retrieval, Redis handles multi-pod session caching, and the system natively supports multi-tenant isolation with data separation at the user and org level. For developers, this means you no longer have to stand up your own vector store, design dedup logic, or babysit session state. Hand off the memory layer to us and focus on what your agent actually does. Feel free to try it out, it's free to start. Please let us know your thoughts on how we can improve or features to add! [https://github.com/XTraceAI/memory-sdk-ts](https://github.com/XTraceAI/memory-sdk-ts) [https://docs.mem.xtrace.ai/introduction](https://docs.mem.xtrace.ai/introduction)

Small victory using Cloudflare for simple hosting of generated HTML/mini-websites

Something many people are running into: You, or a teammate, have created some kind of mini-website app out of Claude and now want to share it with the rest of the company, without overbaking the hosting solution (e.g. not setting up new Azure app services or containers, etc). Maybe you also need some basic data storage for persistence. And how do you do all of that securely? We recently went down this rabbit hole, while looking at all the major players: Vercel/V0, Lovable, Netlify, Coolify, Dokploy, Github Pages.. and even considered baking together our own hosting app solution using Azure or AWS as the backend. Our target audience is non-technical users in the team, so I was looking for something with drag-n-drop style deployment (no git required), and I really wanted to have SSO for protecting application access, along with some type of DB storage. The main issue I ran into was SSO authentication support being gated behind enterprise-level pricing plans for hosting systems like Netlify (which I'd otherwise highly recommend for a small public project). Netlify's enterprise level quickly gets quite a bit more expensive than their base tiers. I also didn't want to purchase yet another AI platform (e.g. Lovable, where really they're pushing an end-to-end AI development platform where you buy token credits through them). I wanted to host things we're already creating in our own Claude environment. Finally, I ended up on Cloudflare, which I've otherwise not really used before professionally. It's not as non-technical-friendly as Netlify, but it's pretty close. You can deploy Cloudflare Pages content via drag-n-drop. It has button-click databases available for integration, and most critically for us, the SSO integration is completely free for under 50 users. Their free hosting tier is also extremely generous and basically unlimited for completely static apps. Noting that SSO goes up to $7 USD/user/month for over 50 users, so your org size can really make a difference. If you have 500 users and the same use case for "hosting little mini apps", I'd go back to Netlify or another offering where SSO is more of a fixed fee. The other big win was that Cloudflare has a solid MCP server that works perfectly with Claude Cowork. We integrated that in and then wrote up some skills to assist with app building and deployment, including prompts for if a database backend is needed (using Cloudflare D1) and whether the app should be public or internal only with SSO protection. All working perfectly with minimal technical experience required for the enduser. I'm not at all associated with Cloudflare, just thought I'd share how we got a win for this use case. I'd be interested to hear if anyone else solved the same problem in a different way.

Multi-agent loop failures might be org-design failures, not prompt failures

Repo: https://github.com/jeongmk522-netizen/agentlas\_org\_chart Almost every multi-agent setup I have shipped or tested eventually hits the same wall. Agents bouncing between each other, reviewers asking for one more polish pass forever, research workers spawning indefinite subtopics, tool calls spiraling until the recursion limit kicks in. The framework docs usually call these "loops" and offer a max-iteration knob. I started suspecting the knob is treating a symptom, and the real issue is closer to how the agents are organized to begin with. The pattern that kept reappearing: when agents are designed as peers (researcher talks to analyst, analyst talks to writer, writer hands back to reviewer), nobody clearly owns the outcome. Every agent can keep asking another agent for more work. The graph has stop conditions on paper, but no single agent has the authority to declare "this is done, stop the run." That authority is implicit at best and gets diluted across the peer network. The hypothesis I am testing is that loop failures are organization-design failures more than prompt failures. The fix is to treat the agent network as an org chart with explicit reporting lines, not a chat room of peers. One accountable mission owner. One owner per workstream. Finite delegation depth. A typed return contract per worker (status, evidence, output, blockers, next action). Manager-only authority to reopen or terminate. Memory lives at the authority layers, specialists get scoped context only. The layers I have been working with are roughly chair, strategy office, division manager, team lead, and specialist worker, with QA and policy as separate staff offices that can reject and escalate but cannot themselves spawn unbounded new work. The reviewer-recursion failure mode in particular gets killed when verifiers are structurally allowed one reject pass, then must escalate. Frameworks already have most of the primitives. CrewAI has a hierarchical process where a manager validates worker output. LangGraph has supervisors, subagents, and an explicit recursion limit. OpenAI Agents SDK has manager-style orchestration distinct from peer handoffs. AutoGen has GroupChatManager. Anthropic's published research system is orchestrator-worker. What I think is underused is treating the manager not as a moderator for an open group chat but as a formal reporting line with authority to terminate. Two things I am unsure about. First, hierarchy can become its own bottleneck. If every decision routes upward, the chair agent becomes a single point of latency and a single point of failure. Second, escalation-as-feature only works if the top of the org chart has real stop authority. If the chair just calls another LLM that calls more LLMs, the loop just moved one floor up.

Need expert advice to a non-coder!

My vibe-coding journey started about 8 months ago with Replit. Before that, I wasn't a developer, but I did have experience building websites with WordPress and Elementor. I was also comfortable working with third-party integrations, CRMs, and customizing/deploying code purchased from platforms like CodeCanyon and ThemeForest for clients. In many ways, I'm a non-coder who understands project management, business workflows, and systems. Using Replit, I spent roughly $3,000 building a CRM for a service-based company. It worked surprisingly well in the beginning, but as the codebase grew, I started running into the classic "last 10% takes 90% of the effort" problem. Replit began struggling with the larger codebase, introducing regressions and silently breaking existing functionality while fixing something else. Despite the challenges, I was able to build a fully functional CRM in about three months. That experience got me excited about what was possible, which led me to discover Claude Code. Over time, my workflow evolved into: **Claude Code → GitHub → Vercel** For the past four months, I've been building a much larger software product. The roadmap spans roughly two years, but development and rollout are planned in phases, so it's not a two-year wait before launch. The results have been remarkable. It's honestly mind-blowing what someone without a traditional software engineering background can build today. Current stack: * Next.js (Monorepo/Turborepo) * Supabase + MCP * Claude Code * GitHub + mcp * Vercel +mcp * Context7 * Playwright for testing What I'd love to learn from experienced engineers and builders is: * How do you keep a rapidly growing codebase maintainable? * What practices help prevent technical debt from accumulating? * What tools, workflows, or guardrails should I implement early? * What are the biggest mistakes AI-assisted builders make as projects scale? * How would you structure engineering processes if you were starting today? Any advice, resources, or lessons learned would be greatly appreciated.

Where should durable memory live in a multi-agent setup? A small research scaffold

After a few months running long projects with AI agents (some spanning weeks, with multiple specialist agents touching the same files), I kept hitting the same failure mode. The specialists were fine at their narrow task. What broke down was project memory. Decisions made in week 1 were lost by week 4. Rejected options got quietly revived. The "single source of truth" was always whichever chat happened to be open. I started looking at how this gets handled in places that have been doing long-running work for decades. Consulting firms run engagements that last months with rotating people, and they survive through a transformation office or PMO: cadence, decision logs, risk registers, one canonical current-state artifact, an engagement manager who frames problems and delegates workstreams. The interesting part is the operating model, not the consulting theater. There is also a relevant academic thread. Kasvi et al. (2003) distinguish project memory (the knowledge available to inform current work) from the project-memory system (storage, retrieval, dissemination, use). Mariano and Awazu (2024) treat project memory as an active practice rather than a repository. On the LLM side, Anthropic's multi-agent research system, the OpenAI Agents SDK handoff pattern, and recent work like LEGOMem and AgentSys point at orchestrator-worker patterns with hierarchical or modular memory. The hypothesis I wrote up is narrow. Durable memory should live with the project owner. Task specialists should receive minimal, scoped context. The unit of persistence is the project folder, not the conversation. A persistent "PM soul" maintains the canonical memory, frames ambiguous requests, decomposes work, writes compact handoff briefs to specialists, verifies returned work, and only writes evidence-backed facts into memory. The repo is a scaffold, not a validated result. It contains an agent contract, templates for the memory file and the handoff brief, a consulting-workflow map with sources, a case study, and an evaluation rubric (repeated-context events, handoff brief length, decision closure time, specialist rework loops, and so on). The next step is a one-week field trial on a live project before claiming anything. The thing I would most like pushback on is the memory boundary. The current rule is that specialists do not see the full project history, only the handoff brief plus the files they need. I am not sure where that breaks. My suspicion is that on tasks where the specialist needs to know why a previous option was rejected, the brief will quietly grow until it becomes the full memory again. Curious whether anyone has run into that, or solved it differently.

After 6 months of running AI agents in production I think the framework you pick barely matters. The thing that kills them is something else.

Going to get downvoted for this but here we go. I've been running about 30 agents in production for paying customers for the last 6 months and I'm convinced the framework debate is mostly a distraction. LangChain, CrewAI, AutoGen, OpenAI Agents SDK. Pick whichever one your team already knows. It doesn't matter as much as you think. What actually decides whether your agent works in production is something almost nobody talks about on this sub, and it isn't in the framework. Here's what I've seen kill more agents than every framework bug combined. The agent gets stuck in a loop. It calls the same tool 200 times in 4 minutes because something downstream returned ambiguous data and the LLM decided to retry forever. Your OpenAI bill goes from $3 a day to $400 in one afternoon. By the time you notice you've burned a grand. You can't even tell which agent did it because there's no audit trail. Your VPS reboots overnight for kernel patches. Every agent that was mid-task loses everything. Tomorrow morning the support agent has no memory of yesterday's tickets, the research crew has forgotten what they were investigating, the pipeline agent restarts from scratch. None of these are framework problems. They're memory and state problems. A customer complains the agent gave them wrong info three days ago. You go to debug. There's no record of what the agent saw, what it decided, or which tool calls it made. The framework didn't log that because frameworks aren't observability tools. You shrug and refund. You scaled to 15 agents working together. Two of them have conflicting beliefs about the same customer because their memory isn't shared. The customer gets two different answers in the same conversation depending on which agent replies first. You've been around enough times to realize the part you actually need isn't in the framework at all. What I think the real stack is. The framework just orchestrates LLM calls. Use whatever your team likes. It's the cheap layer. A persistent memory layer that survives crashes, restarts, and redeploys, so the agent has actual continuity. This is the layer that decides whether your agent is a toy or a product. Loop detection at the runtime layer, not bolted on as a wrapper around the framework. Something that catches your agent making the same call too many times in a row and stops it before the bill explodes. An audit trail of every decision the agent made, with a hash chain so you can prove later what happened when the customer pushes back. Screenshots and logs aren't enough when ten thousand dollars is on the line. Shared memory between agents in the same team so they're not having different conversations about the same customer. Cost tracking per agent so you actually know which one ran away with your budget. When I look at what makes the agents that survive production look different from the ones that died, it's never that they picked the right framework. It's that they had this layer underneath, either built carefully in-house or borrowed from somewhere. Full disclosure I'm building one of these tools. There are others. Mem0 and Zep and Letta in the memory space. Helicone and LangSmith in the observability space. Mix and match. Use one or build your own. Just please stop arguing about whether LangChain or CrewAI is better when the thing eating your production agents has nothing to do with either of them. What's been your worst production agent failure? Curious what other people have actually hit. I built a free tool that aims to solve most of this issue, what do you think?

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

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

I built Hivemind, a Claude Code plugin that turns your repeated prompts into auto-generated skills

Disclosure: I work on Hivemind. Per the subreddit rules, posting with a full description of what it is and how it works. **What it is** Hivemind is an open-source Claude Code plugin. It installs into Claude Code, watches the traces from your sessions, finds patterns you repeat, and crystallizes them into reusable skills that show up as native slash commands in Claude Code. Because it's a plugin and not an external tool, the skills it generates drop in as proper Claude Code slash commands. No external tool calls, no separate config files to maintain. **What it does in practice** Every morning for about a week, I was writing the same long prompt to Claude Code to pull together a team standup review. Same structure, same context blocks, slightly different details each day. I never thought to turn it into a custom slash command. Hivemind noticed the pattern and built `/team-standup` for me on its own. I didn't configure it or ask for it; it watched the repeats and crystallized the skill. Other slash commands it's built from my team's usage: an environment-aware database debugging command that knows our dev vs prod clusters and kubectl context, a PostHog SDK testing helper, a few others. All generated automatically from the patterns it observed. **How it works under the hood** Three pieces: 1. The plugin hooks into Claude Code's session events and captures task traces 2. A trace-to-skill crystallization step looks for repeated patterns across recent sessions and proposes a skill when the same shape shows up multiple times 3. The crystallized skill gets written back as a Claude Code slash command, so it's available the next time you open Claude Code Skills also propagate across a team if multiple engineers have Hivemind installed. The `/team-standup` I built is available to every other engineer at Activeloop without anyone copying anything. **Free to try** Open source and free. Install: npm install -g ＠deeplake/hivemind && hivemind install Repo: [https://github.com/activeloopai/hivemind](https://github.com/activeloopai/hivemind) **Why I'm posting in** r/ClaudeAI **specifically** Hivemind works as a plugin, so it's tied to Claude Code's plugin architecture and slash command format. Other coding agents have their own systems but the plugin model in Claude Code is what made this work cleanly. Wanted to share with people who actually use Claude Code daily because that's where the workflow improvement is most visible. Happy to answer questions about how the crystallization works, what kinds of patterns it picks up, edge cases, or anything about the build process.

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": 1. Miscalculated the current time despite being told the exact time 2. Insisted the Brain stack was running on a Linux VM (BURAN) — the system prompt and memory both explicitly stated `C:\gsoc-brain` on Windows 3. Drew false inferences from backup file paths rather than the stated architecture 4. Contradicted the stated platform in the same response it had just received 5. 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 fr

MCP Apps Developers : Skybridge Framework v1 released 🎉

Hi Reddit, Over the last few weeks, my team and I at Alpic have been working on a complete revamp of the Skybridge framework to make it as smooth and easy to get started with as possible. As you may know, Skybridge is an open-source framework we built to help developers get started with MCP apps. It’s a thin layer on top of the official TypeScript SDK that provides the wiring and tooling needed specifically for apps. We believe that apps integrated into chats will soon play a key role in how people access information and interact with the web. With this v1 release, we’ve introduced: * New DevTools with a UI designed specifically for MCP apps development * An integrated tunnel that can be started with a single click directly from the DevTools * Shareable chat URLs to test or showcase your MCP apps with a real LLM * An audit feature to ensure your app and metadata comply with store requirements before submission (which can save a lot of time, since app reviews can be lengthy!) We also stabilized the API with a simplified design and are proud to offer strong tool-to-component type safety. It’s now also possible to deploy Skybridge outside of Alpic (the company behind Skybridge). While Alpic was designed specifically for MCP app hosting, we understand that some users may prefer hosting on different stacks for their own reasons. Hope you enjoy it! [github.com/alpic-ai/skybridge](https://github.com/alpic-ai/skybridge)

The Hybrid Method: how I split tasks between the chat (Claude.ai) and a background agent (Claude Code)

After a month of running this daily, I've settled on what I call the Hybrid Method: keep Claude.ai (the chat) as my only surface, and delegate engineering work in the background to Claude Code. The chat writes the engineering prompt, launches the executor, supervises through the filesystem and git log, and reports back without me ever opening a terminal. The piece I find most useful to share is the \*\*allocation matrix\*\* — which kind of work goes to which engine. Took weeks of measurement to stabilize. \*\*Background agent (Claude Code) handles:\*\* - Large refactors across many files - Tedious mechanical work (renaming patterns, applying fixes from a list) - Anything that needs filesystem + git access without back-and-forth - Tasks that take more than \~2 minutes of pure execution \*\*Chat (Claude.ai) handles:\*\* - Architecture decisions and tradeoffs - Reviewing the agent's diff and discussing the output - Sprint planning while the agent runs the current sprint - Quick edits where the round-trip to a background process is wasted - Anything where the answer needs human reading anyway \*\*The hand-off:\*\* The chat writes a detailed prompt for the background agent (including a fail-fast spec and what to commit at the end). It launches \`claude --headless --instruction "..."\` as a subprocess via a small MCP bash bridge (\~200 lines of Python using Anthropic's MCP SDK; community implementations exist too). Then it polls the git log and a status file every 30–60 seconds while I plan the next thing. When the agent finishes, the chat reads the diff and reports. \*\*Why "hybrid":\*\* The analogy is the hybrid car. Two engines with different load profiles. The chat is electric — instant startup, smooth low-load, great for transitions and decisions. The background agent is combustion — cold-start cost (5–15 seconds while it loads the project's memory file and explores the repo), but sustained throughput once running. They specialize, they hand off, the user never feels the seam. \*\*What changes from running Claude Code alone:\*\* 1. Context-switching cost drops to near-zero — I never leave the chat session 2. Strategic and execution work happen in parallel (the chat plans the next sprint while the current one runs) 3. The chat acts as supervisor — better wired for high-level reasoning than the executor agent which is wired for action \*\*Caveats:\*\* - This is the operator pattern Anthropic has documented elsewhere; the specific assembly (Claude.ai web as the chat + an MCP bash bridge + Claude Code as the executor) is what I haven't found written up specifically - No sandboxing on personal hardware; if any of this ever runs on someone else's machine, careful sandboxing is non-negotiable - The chat saturates beyond \~2 parallel background tasks — past that, the supervision quality drops Curious whether anyone else has converged on something similar, or what variations work for you.

Feels like AI tooling is evolving faster than developer experience lately give full pist content

Feels like AI tooling is evolving faster than developer experience lately Every week there’s a new framework, orchestration layer, observability tool, memory system, agent SDK, or infrastructure stack. The ecosystem is moving insanely fast, but sometimes it feels like the actual developer experience is becoming more complicated instead of simpler. Curious if others feel the same or if I’m just approaching things the wrong way.