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

You asked for DeepLearning.ai-style notebooks for AgentSwarms—so we built 67 of them (TypeScript/LangChain/LangGraph/LlamaIndex/AgentsSDK/VercelAI).

Hey everyone, A few months ago, We shared the visual canvas we built for AgentSwarms. The response was incredible, but the most common piece of feedback was: "The visual canvas is great for architecture, but I need to see the actual code to really understand how to deploy this." You wanted deep-dive, code-first labs—the kind you see on DeepLearning.ai—but for multi-agent systems, faster and with more flexibility. We’ve spent the last few weeks heads-down engineering a completely new Interactive Notebooks section. As of today, we have 67 TypeScript-based notebooks live on the site (with more dropping soon). What’s in the library: We’ve covered everything from basic LangChain fundamentals to complex enterprise-level multi-agent workflows. Everything runs entirely in your browser using TypeScript—no Docker, no Python venv, no local dependencies. A personal favorite: I’m particularly excited about the "Failure Mode & Error Handling" notebook. We’ve all seen agents that work perfectly in a demo but crash in production the moment a tool times out or an LLM returns garbage. This notebook walks through: How to build deterministic validation gates between nodes. How to force an orchestrator to "catch" a worker failure and dynamically re-route or re-prompt. How to handle state recovery when a multi-agent loop gets stuck in a hallucination cycle. Why we built this: I’m tired of seeing AI "tutorials" that are just static blog posts. To master Agentic AI, you need to be able to tweak a system prompt, break the code, watch the error trace, and fix the routing logic in real-time. The entire library of 67 labs is 100% free to use. If you’re currently wrestling with how to make your agents production-grade, I’d love for you to check them out and let me know if there’s a specific "failure mode" or architecture pattern you’d like us to add to the next batch of notebooks. Try it out here: agentswarms.fyi submitted by /u/Outside-Risk-8912 [link] [comments]

AMD's Lemonade SDK for local AI adds NVIDIA CUDA support

submitted by /u/Fcking_Chuck [link] [comments]

Built and launched a travel planning website with Claude + Cursor over a few weekends. Here are the things AI was surprisingly good (and bad) at.

A few months ago I wouldn't have attempted building a full web application myself. I'm an analytics engineer by profession, not a frontend developer. Over the last few weekends, I used Claude and Cursor to build and launch :https://nomoratravel.in/, a travel planning tool that combines: City guides Weather forecasts Attractions Restaurants Interactive maps AI-generated itineraries Local shopping / souvenir recommendations The stack ended up being: Next.js TypeScript Tailwind OpenStreetMap Gemini Vercel What Claude was exceptionally good at: Product planning Feature design Refactoring large components SEO improvements Structured data/schema markup Generating detailed implementation plans Turning vague ideas into concrete requirements Example: I had a rough idea for a "What To Buy" section. Claude pushed it from: "Show local handicrafts" to "Show specific souvenirs, price ranges, shopping districts, scam warnings, authenticity tips and packing advice." That single conversation probably improved the feature more than a week of coding. Where Claude struggled: Hallucinating APIs Sometimes overengineering simple solutions Large code changes occasionally introducing regressions Not always understanding existing project structure without additional context A few lessons I learned: Claude works best when acting as a product manager and architect, not just a code generator. Long, detailed prompts dramatically improve output quality. Building is no longer the bottleneck. Distribution is. The project is now live and getting its first organic visitors from Google. For those using AI tools regularly: What's the largest real-world project you've shipped with it? https://preview.redd.it/hp4ip6fee66h1.png?width=1693&format=png&auto=webp&s=dce94ca9bbb0cf00f502d17b86a342c416e8fdaa submitted by /u/Parking_Signal7182 [link] [comments]

How should I architect an AI agent that edits a visual canvas through tools / JSON state?

Hi everyone, I’m trying to build an AI agent that can draw, arrange, and manipulate objects on a canvas from natural language prompts. My current approach is roughly this: The canvas is rendered from a JSON file, which acts as the source of truth. The agent uses tools to read and update that JSON. The frontend then renders the updated JSON onto the canvas. I was exploring something like the Claude Agent SDK / tool-use approach, where the model does not directly control the canvas UI, but instead calls tools that modify the underlying state. The issue is that it is not working or feeling the way I expected. One thing I am unsure about is whether the agent actually has enough understanding of the canvas itself. The user sees a visual canvas, but the agent mainly sees tool outputs and the JSON state. So I’m not sure if the “visual understanding” of the canvas is really reaching the agent in a useful way. I’m also trying to understand how these types of problems are usually handled when the agent is doing something other than writing code. In my case, code is not the main thing dictating the changes. The agent is meant to operate on a visual/structured workspace. Any help would be appreciated : )) submitted by /u/Character_Silver2793 [link] [comments]

Cowork plugin examples - what's new in CC 2.1.163 (+5,630 tokens)

NEW: Data: Cowork plugin component schemas — Adds detailed Cowork plugin component format references for skills, agents, hooks, MCP servers, legacy commands, CONNECTORS.md, README.md, and plugin packaging metadata. NEW: Data: Cowork plugin examples — Adds minimal, standard, and complex Cowork plugin templates covering plugin manifests, skills, agents, hooks, MCP configuration, README content, and connector placeholders. NEW: Data: Cowork plugin MCP discovery and connection — Adds guidance for finding MCP connectors during plugin customization, mapping integration categories to search keywords, prompting users to connect MCPs, and writing .mcp.json entries. NEW: Data: Knowledge MCP search strategies — Adds organizational-discovery query patterns for using knowledge MCPs to identify project tools, team conventions, workspace IDs, channels, and workflow details during plugin customization. NEW: Data: Token counting reference — Adds Claude token-counting guidance that uses the Messages counttokens endpoint and Anthropic SDK or CLI examples, with explicit warnings against OpenAI tokenizers such as tiktoken. NEW: Skill: Cowork plugin authoring — Adds instructions for creating or customizing Cowork plugins, including mode selection, research, nontechnical user questions, component implementation, connector replacement, packaging, and delivery as a .plugin file. NEW: System Prompt: Outcome-first communication style — Adds communication guidance to lead with outcomes, write readable teammate-facing updates, match response shape to task complexity, and keep code comments limited to non-obvious constraints. NEW: Tool Description: Browser file upload — Adds a browser file upload tool that uploads shared session files directly to page file inputs by element ref and enforces a 10 MB combined upload limit. Skill: Build with Claude API (reference guide) — Adds token-counting task routing to shared/token-counting.md, instructing agents to use messages.counttokens rather than tiktoken. Skill: Building LLM-powered applications with Claude — Expands supporting-endpoint and task-routing guidance for token counting, pointing to POST /v1/messages/counttokens and the new shared token-counting reference. Skill: /design-sync package source shape — Clarifies that buildCmd is the re-sync build command, that notes are read by Claude and uploaded into the README, and adds troubleshooting entries for remote fonts, .d.ts parsing, style-system prop filtering, invalid providers, and undeclared or missing lib overrides. Skill: /design-sync slash command — Updates the source-shape handoff to describe shared converter scripts under lib/, Storybook entry points under storybook/, and the package-shape entry at package-build.mjs. Skill: /design-sync Storybook source shape — Reworks Storybook syncing around using the repo's own Storybook output as iframe-backed preview cards, building directly into ds-bundle/sb/, requiring React 18+, simplifying configuration, and validating uploaded Storybook artifacts. Tool Description: Bash (sandbox — tmpdir) — Clarifies that $TMPDIR is automatically set to the correct sandbox-writable directory in sandbox mode while preserving the instruction not to use /tmp directly. Tool Description: Workflow — Adds that each parallel() or pipeline() call accepts at most 4096 items and errors explicitly when the limit is exceeded. Details: https://github.com/Piebald-AI/claude-code-system-prompts/releases/tag/v2.1.163 submitted by /u/Dramatic_Squash_3502 [link] [comments]

Learn Agentic AI with quick, easy to run hands on labs, visual canvases and notebooks for free!

If you’re a full-stack engineer or technical architect willing to learn production-grade enterprise agents, you need architecture, security, and type-safe systems. That’s why we builtAgentSwarms.fyi—the ultimate hands-on educational platform for teaching agentic AI and multi-agent workflows. 🚀 The Core AgentSwarms Ecosystem: Real-World Architectures: Skip the generic hello-world loops. Learn production-grade systems like human-in-the-loop validation, automated multi-platform content multiplexers, and secure code-sandbox environments. Deterministic Cloud Guardrails: Deep dives into multi-cloud token economics, dynamic cost-optimized routing, and model evaluation metrics. Grassroots Engineering Focus: No corporate marketing fluff. Just raw, practical code patterns designed to bridge the gap between fragile prototypes and stable cloud deployments. 💣 The New Drop: 60+ Browser-Native TypeScript Notebooks We just completely re-engineered our learning workspace. We’ve added 60+ fully interactive TypeScript Notebooks running 100% natively in your browser. No pip install dependency hell, no local Docker setup, and zero environment friction. Read the architecture, tweak the system prompts or Zod schemas, hit play, and watch the streaming terminal execute live across the five absolute best frameworks in the ecosystem: 🟢 LangChain.js (Fundamentals & Middleware Guardrails) 🔀 LangGraph.js (Cyclic Graphs & Stateful Orchestration) 💾 LlamaIndex.ts (Sentence-Window Retrieval & RAG Triad Evals) ⚡ Vercel AI SDK (Streaming UI Integration) 🤖 OpenAI Agents SDK (Lightweight, low-boilerplate loops) Stop passively scrolling through video courses. Open a canvas, break the graph nodes, and start compiling real multi-agent swarms. 👉 Dive in for free: agentswarms.fyi/learn submitted by /u/Outside-Risk-8912 [link] [comments]

Learn Agentic AI with quick, easy to run hands on labs, visual canvases and notebooks for free!

If you’re a full-stack engineer or technical architect willing to learn production-grade enterprise agents, you need architecture, security, and type-safe systems. That’s why we builtAgentSwarms.fyi—the ultimate hands-on educational platform for teaching agentic AI and multi-agent workflows. 🚀 The Core AgentSwarms Ecosystem: Real-World Architectures: Skip the generic hello-world loops. Learn production-grade systems like human-in-the-loop validation, automated multi-platform content multiplexers, and secure code-sandbox environments. Deterministic Cloud Guardrails: Deep dives into multi-cloud token economics, dynamic cost-optimized routing, and model evaluation metrics. Grassroots Engineering Focus: No corporate marketing fluff. Just raw, practical code patterns designed to bridge the gap between fragile prototypes and stable cloud deployments. 💣 The New Drop: 60+ Browser-Native TypeScript Notebooks We just completely re-engineered our learning workspace. We’ve added 60+ fully interactive TypeScript Notebooks running 100% natively in your browser. No pip install dependency hell, no local Docker setup, and zero environment friction. Read the architecture, tweak the system prompts or Zod schemas, hit play, and watch the streaming terminal execute live across the five absolute best frameworks in the ecosystem: 🟢 LangChain.js (Fundamentals & Middleware Guardrails) 🔀 LangGraph.js (Cyclic Graphs & Stateful Orchestration) 💾 LlamaIndex.ts (Sentence-Window Retrieval & RAG Triad Evals) ⚡ Vercel AI SDK (Streaming UI Integration) 🤖 OpenAI Agents SDK (Lightweight, low-boilerplate loops) Stop passively scrolling through video courses. Open a canvas, break the graph nodes, and start compiling real multi-agent swarms. 👉 Dive in for free: agentswarms.fyi/learn submitted by /u/Outside-Risk-8912 [link] [comments]

I built an LLM observability platform in a weekend — see every AI call, cost and latency in one dashboard

I kept shipping AI apps with no idea what was happening under the hood — prompts going in, responses coming out, costs creeping up, and zero visibility into any of it. So I built LogLens. Add one line of code and it logs every single AI call your app makes — the full prompt, completion, latency, token count, and cost — all in a clean dashboard. Works with Anthropic and OpenAI out of the box. No framework lock-in. npm install loglens-sdk const anthropic = wrapAnthropic(new Anthropic(), { apiKey: 'your-key' }) // that's it — every call is now logged Built the whole thing in ~48 hours using Claude Code. Still early but fully working. Free early access here: llm-watch.vercel.app Would love feedback — what features would make you actually use this day to day? submitted by /u/ProcessAutomatic6941 [link] [comments]

How I pair Claude with other models and use them as adversarial reviewers. It's made vibecoding much easier and my projects don't turn into spaghetti.

Sharing a workflow that's let me build a genuinely complex app (real-time video, GPU, multiplayer) without it all going to shit after a few weeks. I think the biggest issues I've faced in the past were no long-term memory, and vibecoding is still very error-prone on projects with big context. Vision comes from a README document that states *why* I am building what I am building, what problem I am trying to solve, and what kind of outcome would make this project a success. It's a document that I take some time and effort to write because it describes the reason for the existence of the project. Memory comes from an evolvingarchitecture.md that records why each decision was made, not just what. I have lengthy notes in mine that remind whichever model I am using in a fresh session why certain things are they way they are. I feed the doc to Claude at the top of every job and update it after every feature. I have Gemini draft an implementation plan based on whatever feature idea I might have and get Claude to check the work and offer better alternatives. My prompt looks something like this: You are an expert React systems architect and senior TypeScript dev. First read the architecture.md doc. Then carefully verify this implementation plan. Look for problems, edge cases, and anything you'd disagree with. If you find issues, propose alternative solutions. Claude regularly catches edge cases, steps that contradict the architecture doc, and find simpler approaches. When it disagrees it designs a whole alternative. I take its objections back to Gemini, they argue for a bit and we land on a plan that's survived two skeptics. Before any of this, I kill the sycophancy with a system prompt which has been the single biggest upgrade, and it works on both models: Act as my high-level advisor and mirror. Be direct, rational, and unfiltered. Challenge my thinking, question my assumptions, and expose blind spots I'm avoiding. If my reasoning is weak, break it down and show me why. If I'm making excuses, avoiding discomfort, or wasting time, call it out clearly and explain the cost. Stop defaulting to agreement. Only agree when my reasoning is strong and deserves it. Look at my situation with objectivity and strategic depth. Show me where I'm underestimating the effort required or playing small. Then give me a precise, prioritized plan for what I need to change in thought, action, or mindset to level up. Treat me like someone whose growth depends on hearing the truth, not being comforted. The final plan goes to Claude Cowork, which edits the actual files in my codebase so I'm not copy-pasting by hand (I use Sonnet because it's a cheaper on tokens). Here's an overview of my workflow: "the tool I need doesn't exist yet" | v +------------------------------+ | 1. WRITE THE VISION | | --> README.md | | (what it is) | +--------------+---------------+ | v +-> +------------------------------+ | | 2. ARCHITECTURE.md | | | Gemini drafts / | | | Claude sanity-checks | | | == the AIs' MEMORY == | | +--------------+---------------+ | | | ==== THE FEATURE LOOP ================ | | | context in: README + ARCHITECTURE.md | + [ ANTI-SYCOPHANCY PROMPT ] | | | v | +------------------------------+ | | 3. GEMINI: interrogate | | | the idea; | | | "ask me questions" | | +--------------+---------------+ | | you answer --> sharper spec | v | +------------------------------+ git push --> | | | VERCEL auto-deploys | | | | | +--------------+---------------+ | | | v | +------------------------------+ +---| 8. UPDATE ARCHITECTURE.md | +------------------------------+ loop: the next feature re-enters at step 3, with the doc as memory submitted by /u/LorestForest [link] [comments]

We built a source-available LLM reliability library (free for research / personal / internal eval) that can cut inference cost by half at matched quality, and you adopt it by changing one import [P] [R]

TL;DR: Reliability techniques (methods that boost an LLM's correctness by spending extra inference, e.g., retries with feedback, ensembling, generator/critic refinement, verification passes, difficulty-aware routing) are scattered across the literature, each in its own paper-specific codebase. We unified 28 reliability techniques (21 communication-theoretic methods across 6 families plus 7 prior-method baselines: Self-Consistency, Self-Refine, CoVe, BoN, Weighted BoN, CISC, MoA), each measured against an uncoded single-pass baseline, under a single API, with 3 adaptive routers (SemKNN + two local ACM routers) sitting on top, then showed that routing the technique adaptively per prompt lets you slide along a quality/cost frontier. In our paper benchmark with one specific lineup, Nemotron + Devstral as the two generators and GLM-5.1 as the judge, the adaptive router delivered ~56% cost reduction at matched quality, or ~7% quality bump at matched cost, vs the best fixed method we compared against at that same lineup. One knob (λ) does the sliding. The qualitative pattern (adaptive beats fixed) should generalize, but absolute numbers are lineup-specific, and we haven't run the full sweep across other model combinations yet. Adoption is change one import: python - from openai import OpenAI + from agentcodec.openai import OpenAI Pass reliability="harq_ir" (or any of the 28 techniques) and existing client.chat.completions.create(...) calls keep their native OpenAI response shape. Same drop-in shims for Anthropic and Ollama. GitHub: https://github.com/intellerce/agentcodec Working paper: https://arxiv.org/abs/2605.09121 After spending a while researching reliability methods from papers, we kept hitting the same wall: every paper ships its own one-off codebase with its own prompt format, its own scoring rubric, its own model wrapper. Benchmarking "should we use self-refine or best-of-N here?" turned into a week of plumbing per comparison. The communication-theory framing is what tied it together: an LLM is a stochastic channel Y = A(X) + N, and every reliability technique from the wireless world has a direct analog in agent-land: Wireless Agent-land ARQ / HARQ retry-with-feedback loops Diversity combining (MRC/SC/EGC) ensemble multiple models Turbo decoding iterative generator/critic mutual refinement Fountain codes rateless sampling, stop when the judge is confident FEC answer + structured parity passes (re-derivation, verification, alternative), decode by cross-check ACM (adaptive coding-modulation) route by difficulty We put all of them in one library: 28 reliability techniques (the 7 prior-method baselines are part of that 28, not on top of it), plus the uncoded single-pass baseline they're all measured against, plus 3 adaptive routers (SemKNN + two local ACM routers) that select a technique per prompt. Full breakdown in the README. The minimal version ```python from agentcodec import ReliabilityModule mod = ReliabilityModule.from_dict({ "models": [ # Spatial diversity: two different families = uncorrelated errors {"model": "qwen3:8b", "base_url": "http://localhost:11434/v1", "api_key": "ollama"}, {"model": "llama3.1:8b", "base_url": "http://localhost:11434/v1", "api_key": "ollama"}, ], "judge": {"model": "gemma3:12b", "base_url": "http://localhost:11434/v1", "api_key": "ollama"}, "critic": {"same": True}, "strategy": {"type": "fixed", "technique": "harq_ir", "params": {"max_rounds": 4}}, }) result = mod.run("Prove the sum of the first n odd integers is n2.", category="reasoning") print(result.text, result.cost_usd, result.cost_source, result.technique_used) ``` Swap "harq_ir" for "diversity_mrc", "turbo", "fountain", etc. Same API, same ReliabilityResult shape, same cost-source tier on every output. For production, flip strategy to routed and the library picks the technique per prompt (cheap baseline on easy prompts, diversity_mrc on hard ones). Three things worth calling out Beyond the technique catalog, three pieces of the implementation that took real work: 1. Native async streaming for all but 2 techniques (acm_soft, acm_learned), with role-tagged events. mod.astream() drives AsyncOpenAI / AsyncAnthropic / httpx.AsyncClient end-to-end (no worker-thread bridge) and emits TokenEvents tagged with a role: "answer", "thinking", "draft", "critique", "verification", "candidate", "synthesis". So when you stream a HARQ-IR run, you can render the round-by-round drafts and critiques live, not just the final answer: python async for ev in mod.astream("Explain QUIC vs TCP."): if isinstance(ev, TokenEvent): if ev.role == "answer": print(ev.text, end="", flush=True) elif ev.role == "draft": print(f"\n[draft] {ev.text}") elif ev.role == "critique": print(f"\n[CRITIC] {ev.text}") elif ev.role == "thinking": pass # captured to result.thinking_text elif isinstance(ev, FinalEvent): print(f"\ndone — {ev.result.technique_used}, " f"thinking_cost=${ev.result.thinking_cost_usd:.4f}

Been vibe coding with Claude for about three months now as a non-technical founder and I finally launched my first live product!!

Hey everyone, as I’ve said in the subreddit numerous times… I have absolutely ZERO coding background lol but about 3 months ago I started building with Claude Code and I’ve shipped about 11 apps and websites across different projects under my LLC. Some were experiments, some were client builds, and some were for my own ventures! One of the ones I’m most excited about is called LeagueVision™ and it just went live yesterday! It’s an AI fantasy football co-manager that connects directly to your real Sleeper or ESPN league and reads your actual roster. Every answer is built around your specific team, not a generic ranking you have to apply yourself. Here’s what I shipped: - The sit/start analyzer gives you a verdict with a confidence score and the reasoning behind it. Floor and ceiling projections, snap share, opponent rank, and specific risk factors like injury, game script, and weather. - The lineup optimizer runs three scenarios, optimistic, realistic, and pessimistic, so you see your range of outcomes instead of one projection pretending to be certain. - The trade analyzer gives a win/loss verdict, a full value breakdown, and a counter-offer suggestion if the deal is lopsided. - The weekly coaching brief grades your whole team by position, surfaces your start/sit calls, flags trade targets, and points out waiver pickups based on your actual roster and that week’s matchup. - The draft assistant handles round by round strategy, who to pick, sleepers, and a needs analysis based on your league settings and roster. - League history tracks all-time standings, records, head-to-head rivalries, draft grades, and achievements across multiple seasons. The whole thing is built on React, TypeScript, Supabase, and Vercel. Sleeper and ESPN are live. Yahoo is next. Claude was basically my entire engineering team for this. If you’re a non-technical founder building with Claude Code, I’m happy to talk about what that process actually looks like because what’s possible right now is kind of wild. Free to try in your browser at https://leaguevision.app no download needed! submitted by /u/Alex_runs247 [link] [comments]

HORARIOS A TRAVES DE CLAUDE

Buenas a todos, Estoy intentando crear un pequeño software tipo ERP/RRHH para gestionar los horarios de mis trabajadores y me gustaría recibir consejos de gente que esté usando Claude AI, Cursor o herramientas de programación con IA. Ahora mismo gestiono unos 6 trabajadores y sigo haciendo los horarios manualmente en Excel/PDF para después enviarlos por WhatsApp. Cada vez es menos práctico y me quita muchísimo tiempo. La idea es construir una plataforma web donde: Cada trabajador pueda entrar y ver solo su horario Los horarios se actualicen automáticamente Yo pueda gestionar turnos desde un panel visual El sistema genere horarios automáticamente según reglas Los empleados puedan pedir vacaciones o cambios Todo quede centralizado en una única app La parte más importante: Quiero que el sistema pueda generar cuadrantes automáticamente según parámetros que yo configure, por ejemplo: horas semanales/mensuales disponibilidad vacaciones descansos obligatorios turnos fijos preferencias cobertura mínima rotaciones de fines de semana etc. Estoy mirando herramientas como: Claude AI Cursor Next.js Supabase Vercel Mis dudas son: ¿Claude realmente puede ayudar a construir algo así mediante prompts? ¿Qué stack usaríais vosotros? ¿Cómo plantearíais la lógica de horarios y base de datos? ¿Tiene sentido empezar por un MVP simple? ¿Conocéis librerías o frameworks buenos para calendarios y gestión de turnos? No soy desarrollador senior, así que estoy intentando apoyarme muchísimo en IA para acelerar el proceso. Cualquier consejo, arquitectura, experiencia, repositorio o idea me ayudaría muchísimo. ¡Gracias! submitted by /u/Great_Weight4757 [link] [comments]

I built an entire 2D platformer game using Claude Opus 4.8, how's it?

Wanted to see how far I could push Opus 4.8, so I started with a simple prompt "build a 2D single player game" And it just... did it. From there I kept iterating, got a lots of feedback from twitter, Added enemies, scoring system, collision detection, multiple levels(will add), and polished the visuals over a bunch of prompts. What surprised me most was how well it handled game logic no hallucinated physics, clean collision boundaries, enemy AI patterns that actually made sense. For the sprites and assets I generated them with AI on a pink (magenta) background. The game automatically removes the magenta, crops the sprites, and keeps the poses aligned so it animates smoothly. No MCP servers involved, just pure prompting. Opus generated it by itself. A few things that impressed me: It understood spatial relationships in the game world without me having to over-explain Enemy behavior patterns were coherent from the first generation Level design had actual progression, not just random placement The sprite pipeline (magenta background → crop → animate) was Claude's idea, not mine 4.8 is genuinely different for this kind of stuff. It doesn't just write code, it understands how a game is supposed to feel and it's doing it well btw. I tried to build some games with past opus series, but it wasn't capable like 4.8 Built this using cursor and sometimes i used composer 2.5 for small tasks like jumping logic etc Fully playable here: https://pixell-quest.vercel.app/ Happy to answer any questions about the process. Would love to hear what you guys think and if anyone else has been building games with Claude. submitted by /u/Turbulent-Sink-6171 [link] [comments]

I built a search engine for every SKILL.md on GitHub

Couple weeks ago I asked Claude Code to integrate Stripe payments into a side project. It gave me a stripe.charges.create() call (deprecated for two years), no idempotency key, and a retry loop that would double-bill on a 5xx. Standard 2024-training-data Stripe code. But there are good Stripe SKILL.md files out there. wshobson/stripe-integration has 36K stars, written by someone who actually ships Stripe in production. Supabase, Vercel, postgres, OpenAI tool use, basically every API your agent would touch: someone has already written down how to do it correctly. None of those skills ever load by default, because nothing tells the agent they exist. So I scraped all of them. Skillhound (skillhound.ai) is a live index of every public SKILL.md on GitHub. About 135K of them, refreshed every 48h. Web UI is free and doesn't need a signup. The part I actually use is the MCP server: hook it up to Claude Code and before any non-trivial task it searches Skillhound, loads the highest-starred skills from recognized orgs, and uses them as the playbook. An actual concrete example: ask your agent to "build a 30-second launch video in Remotion." Without Skillhound: hardcoded frame counts, drifted audio, broken transitions. With it the agent loads kortix-ai/remotion and sundial-org/remotion-best-practices-2, then ships a driven by useVideoConfig(), transitions interpolated against useCurrentFrame(), audio anchored to a frame cue, and delayRender()/continueRender() wrapped around the asset preload. Rendered first try, frame-accurate, and using the same prompt and model. (Same shape for Stripe checkout, Supabase auth, postgres schema design, OpenAI tool use, frontend design, etc...) (One caveat: sometimes you still have to nudge it the first time ("use skillhound first"). I shipped MCP v0.2.3 yesterday with proactive instructions in the system prompt and it helps, but it's not solved. If anyone has good ideas on how to make agents reach for an MCP tool by default, I'd take them.) submitted by /u/Molil [link] [comments]

I built a kanban that runs Claude on a cron

https://reddit.com/link/1tv0fl6/video/xcz1bbnx0x4h1/player I've been using Claude Code on my laptop for months and it's great while I'm sitting in front of it. But I wanted something a little more autonomous So I built one. It's a kanban board where each ticket spawns a Claude Code session that: Clones the repo into an isolated environment Runs the Claude Agent SDK on the ticket body Commits + pushes via a GitHub App as a bot account (Vercel preview then builds, because the commits aren't from a personal account) Opens a PR Spawns a SECOND Claude session as the QA agent that drives the preview deploy via Browserbase + Playwright MCP If QA fails, the build agent gets the QA report and iterates up to 3 retries The thing I'm most proud of: the MCP integration. I'm in Claude Code and I just say "make a notesasm ticket for the dark mode bug" and it lands on the board with my git remote auto-attached. No tab-switching, no copy-paste. The MCP server runs in our cloud so there's nothing to npm-install. The board also handles recurring tickets. e.g. "every weekday at 9am, read these GitHub issues and file a ticket for anything labeled P0." So when I wake up the board has stuff to review. I'm slowly expanding past just code and have added integrations that can help automate lots of other workflows (like emails, social media posts, outreach, etc) Open beta at notesasm.com free to try - email me at [kavin@notesasm.com](mailto:kavin@notesasm.com) and I'll upgrade you to PRO for free. Trying to find Claude Code users who'd actually use this. Happy to answer technical questions, what would you want to know? submitted by /u/FormExtension7920 [link] [comments]