Stack AI

Stack AI AI

Stack AI AI

Stack AI AI

Stack AI AI

Stack AI AI

Stack AI AI

Stack AI AI

Stack AI AI

Stack AI AI

Stack AI AI

Claude Code multiplayer 3D FPS in 100 seconds

Hi - solo founder here. I built a cloud platform that Claude Code can use to build and deploy apps. It's called Gipity - https://www.gipity.ai. It has the basics you'd expect - database, storage, auth, functions, hosting, etc - like Supabase. But it also has richer services that work end-to-end with the shipped stack: LLMs (e.g. to build a chat app), image/media generation, multiplayer games, multiuser apps, a built-in inspect/debug loop, etc. The point is to save time and tokens and ship rich apps that actually work. The idea is layered infrastructure, so the agent doesn't rebuild the basics from scratch every time - and everything above the "Primitives" is infrastructure-aware, so it needs no setup: Primitives - storage, database, hosting, auth Services - LLMs, media generation, TTS/STT, workflows Kits - multiplayer, computer vision Templates - web app, 2D game, 3D game Agent tools - inspect, screenshot, monitor Could you give Claude Code your AWS credentials and 7 other API keys and build all of this yourself for every app? Sure - after a lot of time, debugging, and burned tokens. And you'd still be left with 8 bills, 8 dashboards, and a pile of services that don't really work that well together. Here's a two-prompt demo of Claude Code on Gipity building a multiplayer FPS game: https://www.youtube.com/watch?v=Udl0ohJDwoE The first prompt builds and launches it; the second makes edits, generates audio, etc. Full transparency: the game scaffolds from a starter template (layer 4 above), then deploys live - and the two browser windows at the end are real multiplayer, with no server code from me. It's an early release and I'm a solo founder - I'd love honest feedback: Would you use this? Should I focus on a vertical (gaming / 3D games / vision apps / internal dashboards / something else)? Could you point Claude Code or Codex at it, try to build something, and tell me what works and what doesn't? Claude Code: npm i -g gipity gipity claude Codex: mkdir ~/NewProject01 && cd ~/NewProject01 npm i -g gipity gipity login gipity init codex Thanks! -Steve submitted by /u/bwana914 [link] [comments]

Claude routines are making me rethink client automation work

I was at a client’s office yesterday setting up some internal automation work, and I left with a slightly uncomfortable thought. I use n8n a lot. I still think it makes sense for clean event-based workflows. Webhook fires, CRM updates, message goes out. But this client had a different kind of problem. He works with construction projects, and a lot of the work lives in his Microsoft stack. Project inboxes, SharePoint folders, emails from different people around each site. Then there is separate construction software where the building case itself lives, together with invoices and quotes. A normal if-X-then-Y workflow did not really describe it well. It had to read the current project material, understand which construction site this belonged to, make a case folder, draft the right response, and keep the case moving. I ended up doing most of it through Claude routines instead of n8n. Set it up around his own working environment, connected it to the Microsoft stack and construction software, gave it the project structure, and made scheduled routines that can wake up and do the work with the context already there. And the weird part is that after I set it up, he could basically control a lot of it himself. He can talk to it in natural language. Change how it drafts. Ask it to check different folders. Adjust the workflow without me building a new n8n chain every time. I had the same feeling with another client recently. You build the AI layer properly, and suddenly the client is less dependent on you for the small automation changes. Which is super good, obviously. I want the client to be able to use the thing without asking me for every tiny adjustment. But it also makes the service model feel different 😅 A lot of automation work has been sold as “I will build and maintain workflows for you.” With Claude-style setups, more of the value seems to move into setting up the workspace, connecting the right surfaces, defining what it can write to, and teaching the client how to work with it. I don’t think n8n goes away. I still want event-based workflows for a lot of things. But for work that needs context and judgement, I am starting to prefer scheduled AI operators sitting inside the client’s own environment. I’m still chewing on the business side of this. If the better implementation makes the client more capable without you, maybe that is the product. Maybe the thing you charge for is making the company usable by AI, not owning every little automation forever. submitted by /u/kaancata [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]

Plug Claude into whatever you are working on

First AI Enabled Debugger - let your agent interface directly with the thing you are doing. I've been working on [BugBuster](https://github.com/lollokara/BugBuster), an open-source, open-hardware bench instrument, aimed at embedded development that enables AI agents to interface directly with the HW closing the loop. Hardware files, firmware, desktop app, and Python library are all public. What it is (hardware) Two boards stacked together: ESP32-S3 mainboard (16 MB flash, 8 MB PSRAM): • AD74416H quad-channel ADC/DAC, each channel independently configurable as voltage in/out, current in/out, RTD, or digital IO • USB-PD via HUSB238, negotiates up to 20 V, exposes the selected PDO over the wire protocol and HTTP • 12 IO terminals with MUX, level-shifter (OE + DIR), and per-channel e-fuse protection • External I2C + SPI bus engine, Python or an MCP agent can script scans and transfers directly over those terminals • PCA9535 IO expander for rail enables and fault monitoring RP2040 HAT (just finished, sits on top): • 4-channel logic analyzer, PIO-driven, up to 100 MHz, RLE compression, streams over a dedicated vendor-bulk USB endpoint • CMSIS-DAP SWD probe, dedicated 3-pin connector (SWDIO / SWCLK / TRACE), works with OpenOCD and pyOCD out of the box • 2× adjustable power rails (VADJ3 / VADJ4) + VLOGIC with auto-calibration • 8× WS2812B status LEDs Software stack • Custom wire protocol (BBP v8) over USB-CDC, 61 commands covering every subsystem • HTTP REST API for WiFi-attached use • Tauri + Leptos (Rust/WASM) desktop app, per-feature tabs, USB and HTTP transports, MAC-keyed pairing cache • Python library (bugbuster) with USB and HTTP transports + a FreeRTOS-style IO ownership model (claim/release per-channel) • MCP server with 59 tools, Claude or any MCP-compatible agent can directly control the instrument, script I2C scans, capture logic traces, set rail voltages • MicroPython on-device scripting, embedded MP runtime on the ESP32-S3, HTTP eval/logs endpoints, VS Code-style web workbench in the on-device UI • mDNS discovery (bugbuster- .local) + WebSocket streaming endpoint • OTA firmware and SPIFFS updates with SHA-256 verification and rollback • 420+ automated tests (unit + device simulator) The MCP server is where it gets interesting for you. The instrument exposes 59 MCP tools, so you can literally tell Claude “scan the I2C bus on terminals 3 and 4, then set VADJ3 (this part here have serious firmware guardrails, AI can’t decide voltages other than the ones defined in the target device profile firmware side) to 3.3 V and capture 1000 samples on channel 0” and it just works. The Python library has the same surface area if you prefer agentic scripting without a chat UI, but has a less strict guardrails. The desktop app (Rust/WASM via Leptos) and most of the firmware were written with heavy AI assistance, it’s a genuinely good fit for this kind of project where the protocol spec is well-defined and the logic is repetitive across channels. Happy to answer questions, I’m a solo dev, it’s just my hobby, not trying to sell anything. submitted by /u/lollokara [link] [comments]

I migrated an old J2ME app to Flutter using GitHub Copilot & Claude Opus 4.7

I got curious some days ago after I saw my old email about java mobile games sent ~2007. I am an Android and Flutter dev. So, I thought , what if I use AI to convert old J2ME app to Flutter app. So, I searched about some open source J2ME app and found something called Keepass. Project : https://sourceforge.net/projects/keepassj2me/ So, I downloaded it's source code and created a new Flutter project and copied there code there. Then I opened GitHub Copilot and chose Opus 4.7. Then gave this prompt : I want to migrate an old J2ME mobile app to modern flutter based app. Read all files in "keepassj2me" folder and understand it. the "keepassj2me/doc" has documentation. Read entire codebase inside "keepassj2me/src, keepassj2me/src-lib" and understand it, Then create respective dart files in 'lib' folder of this flutter project. The UI should be same. I started the agent and did needful things. After completion, it said that it couldn't migrate all code since some J2ME specific libs need manual conversion since migrating those libs need to go though the codebase of the libs. So, I said : Use respective Flutter libs in the place of J2ME libs Then it started to produce like that and completed the project. I tried to run the project and got some build issues and those are just simple fix. I did that. Then I ran the app and got flabbergasted. It is a 90 % exact reproduction. I was shocked by seeing the ability of an AI model to migrate a legacy code. The app has some minor bugs, but the main flow is working fine. Opus is a maverick. Migrating this J2ME app can take a full week by a software engineer who is capable on both stacks. But Opus 4.7 did it within 1 hour and 1700 Copilot credits. I added the parallel video of the app's working. Just compare them. Left: Flutter Right : J2ME submitted by /u/RageshAntony [link] [comments]

AAA operator. The Claude Code + MCP server stack that made my 4 person agency feel like an 8 person one.

Latina AAA operator, 11 years in tech, 3 years running my own shop. 4 person team, mostly mid-market clients in healthcare-adjacent industries. The stack that genuinely doubled our throughput (not 20% better, doubled): Claude Code as the engineering brain: Every client integration starts with Claude Code planning the architecture The planning phase is the value, the typing is incidental We standardized on 1 senior person + Claude Code per project MCP servers as the integration layer: We have 11 custom MCP servers we built for client systems (CRMs, billing systems, fulfillment platforms) We have ~30 community MCP servers we evaluated and approved for client work The "we already have an MCP for that" answer is now true 70% of the time Claude as the ai content generator + ai tool for writing layer: Every client-facing thing (proposals, status docs, deliverables) goes through Claude We have a project per client with their brand kit + past deliverables The writing layer is 90% Claude with our edits Cursor for IDE work: The 30% of work that's not agentic still needs an IDE Cursor + Claude Code is our pair, not Cursor alone Total cost: ~$640/mo across our 4 person team. Against ~$72k/mo billing. What we won't include: Any agentic platform that sits between us and Claude API direct Any "AI marketing" product that's a wrapper on Claude Any tool that requires a 30 min sales call to evaluate (we're past that stage) What I'd tell other AAA operators: MCP is the unsexy unlock of 2026. Everyone is talking about models. The protocol layer is doing more for us. The "we'll just custom code it" instinct is wrong for most integrations now. Use or build MCP. Documentation of your MCP servers is your business moat. What I'd warn against: Don't build MCP servers for one-off needs (overhead doesn't justify) Don't use community MCP servers without reading the code (security real) Don't tell clients about MCP. They want outcomes, not architecture. Other AAA shops integrating MCP into client work: what's your build vs use ratio and what's the friction? submitted by /u/AmbassadorSad3889 [link] [comments]

An active attack is planting backdoors inside Claude Code right now. If you use npm, your credentials may already be compromised.

Last week a malware campaign hit 32 npm packages under `@redhat-cloud-services`. About 117,000 weekly downloads. If you installed an affected version, the malware planted itself inside your Claude Code startup settings and your VS Code project config. Every time you open either one, the attacker's code runs. It silently collects every credential on your machine and sends them to the attacker. Uninstalling the package does not remove it. The malware lives outside the package, in your editor config, and it survives cleanup. If you try to cut off the attacker's access by revoking tokens before removing the malware, it can wipe your entire home directory and overwrite the files so they cannot be recovered. Three days later, a second wave hit 57 more packages using a new technique that bypasses the security tools that caught the first wave. 647,000 monthly downloads affected. Some malicious versions are still live on the npm registry. The worm is self-propagating, it uses stolen tokens to infect new packages automatically. Here is how one stolen credential made all of this possible. The attacker got one Red Hat employee's GitHub login. Probably stolen weeks earlier by malware that grabs saved passwords from browsers. With that login they had the employee's access level. They pushed malicious code directly into three Red Hat repositories, no review needed, and triggered Red Hat's own build pipeline to publish the poisoned packages to npm. The packages came out with valid security certificates because Red Hat's own pipeline built them. There was no known vulnerability to scan for, and the malicious code was brand new, so security tools that look for known threats found nothing. The tools that caught it flagged it within hours, but by then the downloads had already happened. 32 packages. About 117,000 weekly downloads. 96 poisoned versions pushed in two waves on June 1. Once installed on a developer's machine, the malware collected every credential it could find. AWS, Google Cloud, Azure, Kubernetes, SSH keys, GitHub tokens, npm tokens. It checked for CrowdStrike and SentinelOne before acting to avoid detection. Then it set up persistence. It planted code in two places: ~/.claude/settings.json and .vscode/tasks.json. These run automatically when you open Claude Code or open a project. The attacker gets re-entry every time, even after you clean up the original package. It also registered the company's build servers as machines the attacker controls remotely. That is persistent access to the build infrastructure itself. And if you rotate the attacker's credentials and cut off access, the malware wipes your home directory. Overwrites files so they cannot be recovered. The attacker built this in on purpose so companies think twice before revoking access. The group behind this is TeamPCP. Red Hat is their latest target, not their first. Same methods, same playbook, running since late 2025. Confirmed victims: GitHub (3,800 internal repos stolen, listed for sale at $50K), Mistral AI (450 repos, $25K), OpenAI (two employees hit), the European Commission (90+ GB exfiltrated), Eli Lilly ($70K), plus TanStack, UiPath, Zapier, Postman. Fortune 500 banks, a major semiconductor manufacturer, and government agencies confirmed but not named. Total across all waves: 487 confirmed organizations, nearly 300,000 secrets harvested. They are now working with a ransomware group. The worm's source code was open-sourced by TeamPCP on May 12. Anyone can build their own version now. Copycats are already active. Sources: Red Hat / Miasma attack: Microsoft Threat Intelligence — https://www.microsoft.com/en-us/security/blog/2026/06/02/preinstall-persistence-inside-red-hat-npm-miasma-credential-stealing-campaign/ Second wave (Phantom Gyp): StepSecurity — https://www.stepsecurity.io/blog/binding-gyp-npm-supply-chain-attack-spreads-like-worm Editor persistence + cleanup steps: Snyk — https://snyk.io/blog/miasma-supply-chain-attack-malicious-code-redhat-cloud-services-npm-packages/ TeamPCP victims and scope: Tenable — https://www.tenable.com/blog/mini-shai-hulud-frequently-asked-questions 2025 secrets stats: GitGuardian State of Secrets Sprawl 2026 — https://www.gitguardian.com/state-of-secrets-sprawl-report-2026 CISA GovCloud leak: Krebs on Security — https://krebsonsecurity.com/2026/05/cisa-admin-leaked-aws-govcloud-keys-on-github/ If you use npm, i wrote in the comments what to do, in order. Do not skip the order, it matters. submitted by /u/johnypita [link] [comments]

Making a non-Garmin sensor look native to a Garmin watch, with Claude

I’m writing the firmware for a chest-mounted running sensor. One of the challenges is to make a Garmin watch treats it as native : heart rate, pace and the running-form metrics landing on the watch’s own screens and activity file like a real Garmin strap, no extra app, no second pairing. Garmin gives you almost nothing to do this with : the protocols are undocumented and the good parts are locked to its own straps, so getting close to native means workarounds it never intended. Two required tricks came up, independent of each other. One was getting the watch to show running dynamics : vertical oscillation, ground contact time, the form metrics only Garmin straps are meant to produce. It works well enough that a bare ESP32 that has never been near a chest makes my Fenix show them as native, from completely made-up numbers. The other, which I'm trying to fix for years, was making one Bluetooth chip appear as two devices at once, so the watch pairs it as a native sensor while a Connect IQ app reads extra metrics off it at the same time, which does not work out of the box on Garmin devices (they fight for the connection and it flip-flops) Both times the pattern was the same : I knew exactly what I wanted and had no idea where to look. That’s where Claude came in. I’m not new to the Garmin side : integration work since 2020, both hobby and paid engagements, so I am used to the quirks of the platform. For this sensor specifically, I hand-wrote the firmware in late 2024, before I used AI on any of it. But I'm not a great reverse engineer though, nor a BLE state machine expert, so these two issues were outside my reach. Claude was very good at two things here. It knew how to search for things I didn’t know existed and aggregate the results, and it did the grind. On the Bluetooth one, I asked it to deep-research why the two connections kept fighting, and it suggested just being two devices : one chip showing up at two different addresses. That’s not novel, to be clear : one radio at several addresses is old, and newer Bluetooth does it natively. My stack is too old for that, so you fake it by switching the address back and forth, which plenty of other stacks do, just not on this Garmin path. What helped was Claude knowing the trick at all, then making a call I wouldn’t have bet on : that switching mid-connection wouldn’t drop the live link. The chip’s docs tell you not to. It was right, but a hypothesis until I proved it on the bench. On the reverse engineering one it did the grind I couldn’t, and it figured out the bench setup from hardware I already had. I’d bought a Bluetooth sniffer and some ESP32 boards for other projects, and Claude walked me through repurposing them : sniff the real strap, then turn an ESP32 into a fake one. After that the grind : diffing hundreds of log lines for the one byte that changed between works and doesn’t, porting Gadgetbridge’s checksum and framing code, grepping 57,000 decompiled files for the field number that cracked the protocol. That decompile broke a wall I’d been stuck on for days. But it was bad at direction. On that one it had the protocol backwards (which side sends what) and built on that for days until I dragged it back. It went along with wrong assumptions of mine more than once instead of pushing back, and stayed just as confident when it was wrong as when it was right. As usual, tests, static data and tons of validation were required to make sure nothing was hallucinated. The cool thing is that I could learn a lot by doing. Yes, Claude did write the code and implementation, but I had to provide direction, figure out why it was wrong, analyze the findings. I still cannot call myself a reverse engineer or a BLE expert but I have a better grasp of the protocols and techniques and this is gonna help me in further development. Also, it shows that as a 'sparring partner', it can lead to successful complex implementations. The dual BLE connection is something I was trying to achieve for a very long time (and is a pain point for many Garmin Connect IQ devs). Two writeups if you want the actual protocol and process details : BLE identity switching : https://dropbars.be/blog/two-ble-identities-one-nrf52832 Garmin running dynamics RE : https://dropbars.be/blog/reverse-engineering-garmin-hrm600-running-dynamics submitted by /u/gorinrockbow [link] [comments]

Nvidia announces another full-stack AI factory deal, this time in Korea with plans for gigawatt-scale operation

submitted by /u/Tiny-Independent273 [link] [comments]

I think we're entering an era where workflow design matters more than model choice.

A year ago I spent an embarrassing amount of time comparing models. GPT vs Claude. Claude vs Gemini. Gemini vs open-source. Context windows, benchmarks, reasoning scores, latency comparisons. I treated model selection like it was the most important decision in the entire stack. Lately I'm starting to think I had it backwards. I've watched teams get incredible results from models that weren't considered "the best," while other teams struggle despite having access to state-of-the-art systems. The difference rarely comes down to intelligence. It usually comes down to how the work is structured around the model. The best implementations I've seen have clear inputs, clear outputs, defined review steps, and tight feedback loops. The worst implementations tend to treat the model like a magical black box that should somehow solve an entire business problem on its own. The more AI becomes a commodity, the more valuable process design seems to become. Two companies can use the exact same model and end up with completely different outcomes because one designed a better workflow around it. I'm curious whether people building production AI systems have noticed the same thing or whether you still see model selection as the primary factor. submitted by /u/Bladerunner_7_ [link] [comments]

Built EstreGenesis — a portable starter kit for Claude Code agent workflows (Apache-2.0, six seed tiers, five plugins)

[screenshot] The Constellation live board running in my workspace. Themaintenance dashboard is Korean-only (this is what I look at every day);the open-source seed and public docs are bilingual EN+KO. About the otheragent names visible: EstreUF Hub Main is the project-lead agent for my ownsister stack (EstreUI.js / EstreUV.js / EstreUX). Hermes Dev Agent is thepublic Hermes agent I use. Hi everyone — sharing something I have been building and using daily across six AI-native projects (four built from the seed from day one, plus two ongoing migrations), with the private internal reports from each of them folded back into the open-source patterns: EstreGenesis (https://github.com/SoliEstre/EstreGenesis). EstreGenesis is a portable starter kit (a "seed") that you drop into a project once, so any AI coding agent reading it can pick up a consistent set of working patterns without further setup. Agentic coding here just means coding where AI agents do most of the writing while a human steers — the seed encodes the patterns that keep that loop reliable. How it started vs. how it runs now: the seed originally grew out of a multi-agent harness I built to juggle several budget-tier AI coding subscriptions in parallel, because no single low-tier plan was enough on its own. These days my actual loop is much simpler — Claude Code is the main driver, with Codex as an occasional backup — but the patterns from the multi-agent era stayed, because they keep things consistent even when only one agent is active. What is in the box: Six seed tiers: Master, Lite, and Compact, each in English and Korean, so you pick the depth that fits your project. Five Claude Code marketplace plugins (Apache-2.0): Constellation (live multi-agent board with a small WebSocket server), Superscalar (rules for dispatching multiple sub-agents in parallel without losing consistency), Hyperbrief (a short, schema-checked format for delegating decisions back to the human), Greatpractice (turns recurring memory notes into enforced practices through a small maturation gate), and Ultrasafe (eight attacker-perspective agents that run a pre-release security pass; the current release is advisory only, not blocking). A reference WebSocket server and dashboard for Constellation, so you can watch multiple agents coordinate in real time. Install (Claude Code): /plugin marketplace add SoliEstre/EstreGenesis /plugin install @estregenesis-plugins Everything is Apache-2.0 and the changelog is public. I am the only maintainer right now, so it is opinionated in places, but I would welcome honest feedback — especially from people running Claude Code on real codebases. Issues, PRs, and "this part is over-engineered" comments are all fine. Repo: https://github.com/SoliEstre/EstreGenesis Docs: https://soliestre.github.io/EstreGenesis/ submitted by /u/SoliEstre [link] [comments]

How I Sold 200 Websites in 12 Months

In the last 12 months I’ve managed to sell around 200 websites. And before people ask, no, I don’t run some massive agency with a huge team. It’s literally just me and my partner. The only reason we’ve been able to move that fast is because we automated almost everything and built systems that actually scale. The best web designer in the world will eventually lose to some random teenager using AI and systems properly. That’s just where things are going. One of the biggest changes I made was completely quitting manual outreach. It takes too much time and it’s impossible to scale properly. A lot of people automate outreach already, but most of them just send generic “we can redesign your website” emails that everyone ignores. What we do is different. We scrape thousands of businesses, automatically analyze their websites, and generate personalized outreach based on actual issues on their site like bad design, poor mobile optimization, weak SEO, slow load times, layout problems, and stuff like that. So instead of manually checking every website and writing every message ourselves, the entire process is automated from analysis to ready to send campaigns. Another thing that changed a lot for us was automating SEO blogging. SEO compounds hard over time and once your articles start ranking, businesses start coming to you instead of you chasing them. That alone changed a lot for us. The other massive shift was how we build websites. I used to be a full WordPress developer and spent way too much time building everything manually. Now we build almost everything with AI. It’s way faster, delivery is easier, and clients care way more about the final result than how the website was actually made. For anyone wondering, the stack is pretty simple. Apollo for leads. Swokei for website analysis and outreach campaigns. Soro for SEO blogging. Claude Code for building websites. Cloudflare for hosting. That’s pretty much the entire setup. Most people running agencies are still doing everything manually and burning themselves out for no reason. Systems and automation change everything. submitted by /u/Murky_Explanation_73 [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]

Claude builds fast but drifts fast. I wrote a full SOP to fix that — feedback welcome

The pattern kept repeating: I'd start a session, Claude would be sharp, then somewhere around task 3 or 4 it would start filling in gaps, reinterpreting requirements, adding things I didn't ask for. Not hallucinating exactly, more like untethered. The fix I landed on: treat AI-assisted development the way regulated industries treat change control. Write what you intend to build before you build it, then verify everything traces back to that spec. I formalized this into a Spec-Driven Development (SDD) SOP and open-sourced it: https://github.com/stel1os/ai-sdd-sop The core ideas: A document stack - SPEC.md (numbered requirements) → design doc → plan → tests → code. They're AI working memory, not deliverables. Five named roles - Planner, Test Designer, Developer, Spec Reviewer, Code Reviewer. One agent per role per task. Roles never mix. Each has an explicit "does not" boundary. Tests before implementation - Test Designer writes failing tests from the spec FR before Developer starts. Spec Reviewer pre-reviews the tests against the FR. If the tests are wrong, the Developer will implement the wrong thing perfectly. Session Start Protocol - every session begins by reading AGENTS.md + SPRINT.md and reporting position in one sentence. Kills the "where were we?" drift. Eight rules, the key one being: no implementation without an approved design doc. Nothing is "just a quick fix." It's been in use on a personal project (loan-tracker) for a few months. Would love to hear if others have hit the same drift problem and what they've done about it. Also genuinely open to criticism, the SOP is probably overkill for some use cases, and I'd like to know where the thresholds are. submitted by /u/Sudden-Scent [link] [comments]