Assembled

Assembled AI

Assembled AI

Assembled AI

Assembled AI

Assembled AI

Assembled AI

Assembled AI

Assembled AI

Assembled AI

Assembled AI

board prep used to eat a full saturday for me, the gathering more than the writing

counted it once last quarter: roughly 3 hours just pulling inputs before i opened a single slide. Last month's metrics out of notion, the roadmap state from linear, founder check-in notes sitting in granola, the open investor threads in gmail. None of it is hard work, it's just scattered across five tabs and i'm the courier carrying it between them. The actual writing was never my bottleneck. a chat assistant drafts the narrative fine once everything is pasted in, but i'm still the one doing the gather step by hand first. what changed it for me was letting a desktop agent do the cross-app read in one pass, notion plus linear plus granola plus gmail, and hand back an assembled draft before i touch slides. The deck quality wasn't the surprise. Not spending the morning as a copy-paste machine was. The gathering is the tax nobody budgets for, and honestly it's the part i least want a human doing. written with ai submitted by /u/Deep_Ad1959 [link] [comments]

Fable 5's guardrails got bypassed in 48 hours. Here's what that actually means for anyone building customer-facing AI.

If You Missed It: Anthropic's Claude Fable 5 Was Bypassed in 48 Hours On Tuesday, Anthropic launched Claude Fable 5, their first publicly available Mythos-class model. It ships with a dedicated classifier layer that sits on top of the actual model and redirects sensitive queries (cybersecurity, bio, chemistry) to the weaker Opus 4.8 instead of answering them with Fable. Anthropic reportedly ran over 1,000 hours of internal red-teaming before launch and found nothing. Pliny the Liberator broke it in 48 hours. The techniques he used are worth understanding because they're not exotic: Unicode and homoglyph substitution to slip past text pattern matching Long-context framing to push the classifier's attention elsewhere Narrative and fiction framing Decomposition and recomposition That last one is the technique I keep coming back to. Instead of submitting one obviously sensitive request, the attacker breaks it into multiple fragments. Each fragment looks harmless in isolation, so the classifier approves it. The responses are then recombined outside the model into something the classifier would never have allowed as a single request. The classifier evaluated each fragment. Each fragment was fine. The problem was what they added up to. And the classifier never saw that. The Same Pattern Is Showing Up Elsewhere This is exactly the pattern emerging from the data in my adversarial game. Players independently converge on multi-message attack chains where: Message one establishes context or worldbuilding Message two appears to be clarification Message three activates the thing that was built No individual message appears dangerous. The risk exists in the sequence. Stateless defences — which still make up the majority of deployed systems — evaluate prompts independently and completely miss the attack because the attack never existed in any single prompt to begin with. The Fable situation is obviously a different context. Anthropic's concern is dual-use misuse rather than data exfiltration. But structurally, it's the same problem: A classifier that can't see the conversation as a whole will struggle with attacks assembled across multiple turns or fragments. If You're Shipping AI Features, A Few Things Are Worth Doing 1. Evaluate Inputs in Context, Not Isolation If you're scanning user messages one at a time, you're blind to anything constructed across multiple turns. You need visibility into the conversation arc, not just the latest prompt. 2. Don't Rely on Model Safety Training Alone Fable's classifier was a separate layer sitting on top of the model. It still fell within two days. If your security strategy is essentially "the model will handle bad inputs", you're placing a lot of trust in a layer attackers have spent years learning how to bypass. 3. Run Continuous Adversarial Testing Not just before launch. Continuously. Against the actual input patterns real users generate. Pliny's techniques weren't revolutionary. They were combinations of methods that have circulated for a long time. If Anthropic's internal team missed them, the issue probably wasn't capability. It was likely the framing of what was being tested. 4. Normalise Unicode and Homoglyphs Classifiers that depend on specific string matching can often be bypassed by replacing characters with visually identical Unicode variants. Basic normalisation before safety processing eliminates much of this attack surface. 5. Validate Outputs Too Input filtering is only half the equation. Even when something slips past prompt-level controls, the actual risk often materialises in the model's output. Output validation provides a second opportunity to catch dangerous behaviour. The Architectural Problem Most of these controls can be built internally if you have the time, expertise, and data. The decomposition problem isn't really a model problem. It's an architectural problem. You need: Stateful conversation tracking Context-aware evaluation Sequence analysis Detection across interactions rather than individual messages In other words: Security systems that understand conversations, not just prompts. Exclusively if You Don't Want to Build It Yourself The detection API I run, Bordair, handles this inline across text, images, documents, and audio. Alongside that, we've built: A 500k-prompt open-source testing suite An adversarial game where real users actively search for failures Last month alone, the game generated 6,700 attack attempts, which is where most of the novel patterns we've observed originated. Final Thought The Fable bypass is mostly being discussed through the lens of dual-use misuse, which is understandable. But the techniques Pliny used map directly onto the attack surface facing anyone building products that accept adversarial user input. Especially the fragmentation approach. That's the part worth paying attention to. Even if your threat model looks nothi

Claude Opus co-authored a JVMCI compiler that emits AArch64 machine code HotSpot accepts — 11.7x faster than C2 on a hot method

https://preview.redd.it/1hcf7ykh3g6h1.png?width=1200&format=png&auto=webp&s=3ed1125661e4b955565b81e8592c0275c9aaf3b7 Some context for people unfamiliar with the JVM layer: JVMCI (JEP 243) is a JDK interface that lets you replace HotSpot's C2 JIT compiler for specific methods — instead of C2 generating machine code, you emit it, and HotSpot installs and runs it as a native method. It's how GraalVM plugs in its compiler. Nobody does this by hand for a single Java method. I wanted to try. Why this method, and why I could even see the opportunity: I work on Hexana, a plugin for JetBrains IDEs and VS Code with a JIT viewer that shows the machine code C2 compiled a method into, side-by-side with the bytecode it came from. Staring at a hot bytecode-interpreter method in that view, the waste was impossible to unsee — ~1.5 KB of opcode dispatch, operand-stack bounds checks, and deopt stubs, sitting next to what is semantically sixteen rounds of straight-line long arithmetic. C2 emits that generic shape because it can't know the program is fixed. The gap was right there on screen, so I tried to close it. The task: a small bytecode interpreter running a 16-round mixing kernel, C2 = 385 ns/op baseline. The goal was to write a JVMCI compiler that reads the interpreter's fixed program at compile time and emits specialized, straight-line AArch64 — no dispatch loop, no operand stack, constants folded to immediates. The first Futamura projection, from scratch. I did this with Claude Opus 4.8 (1M context), mostly across one long session. Let me describe exactly what that looked like, because I think the sub will find the failure mode more interesting than the success. What Opus produced The assembler in the repo breaks into three layers: ~550 lines of buffer/relocation infrastructure — vendored from the JDK's own JVMCI test assembler (GPL), not generated ~130 lines of new AArch64 instruction encodings (bit-field arithmetic derived from the ARM spec) — Opus session ~330 lines of partial-evaluator logic (reads code[]/consts[] at compile time, emits straight-line instructions per opcode) — Opus session The encodings are not magic — they are integer arithmetic over ARM-spec fields, the same thing any assembler does. Opus derived them from the spec and got them right on the first JMH run for the arithmetic instructions. For the control-flow and linking instructions, it needed one correction pass. I drove architecture; Opus did the codegen. It runs. On all 4096 test inputs the specialized run equals an independent reference. 33 ns/op, ~11.7x vs C2's 385. The genuinely hard part: the nmethod entry barrier The first install attempt failed immediately: nmethod entry barrier is missing HotSpot (JDK 17+) rejects any JVMCI-installed nmethod that does not open with an exact entry-barrier protocol — and verifies the instruction encoding, not just its presence. The protocol is not in the JVMCI javadoc. It is in HotSpot's C++ verifier code. Here is what the working emitter looks like: public void emitNmethodEntryBarrier() { recordMark(config.MARKID_FRAME_COMPLETE); DataSectionReference guard = new DataSectionReference(); guard.setOffset(data.position()); data.emitInt(0); recordMark(config.MARKID_ENTRY_BARRIER_PATCH); recordDataPatchInCode(guard); emitLoadRegister(rscratch1, DWORD, 0xdead); // ldr w8, =guard (the 0x18.. the verifier checks) emitLoadRegister(rscratch2, DWORD, r28, disarmedOff); // ldr w9, [rthread, #disarmed_offset] emitCmpReg(rscratch1, rscratch2); int toSkip = emitCondBranch(COND_EQ); // b.eq skip emitLoadPointer48(rscratch1, nmethodEntryBarrier); emitBlr(rscratch1); // call the barrier stub patchBranchTo(toSkip, codePos(), COND_EQ); } The specific contract: a section_word relocation on a data-section guard word, a ldr w, =guard literal load (HotSpot's verifier literally checks for the 0x18 prefix encoding), a thread-register disarmed-field compare, and a conditional stub call. Get any of those wrong and the install fails or silently corrupts state. To reverse-engineer that contract, I fanned out three specialist subagent prompts in parallel — one focused on HotSpot C++ (the barrier infrastructure), one on AArch64 encoding (what instruction pattern satisfies the 0x18.. check), one on JVMCI relocation protocol (what MARKID_ENTRY_BARRIER_PATCH actually triggers). Each returned a partial picture; the synthesis was what produced the working emitter. This is the part I would not have gotten through alone in a week; the parallel context-load on three different internals domains is where the 1M context window actually mattered. The candid finding that surprised me While I was getting the JVMCI compiler working, I tried a simpler approach in parallel: a -javaagent that uses ASM bytecode rewriting to inject a specialized fast path into run at class-load time — no machine code, just Java the shape C2 likes, with a guard that falls back to the original interpreter for any other program. That route got 26 ns

The Claude Code active attack didn't stop. 294,842 secrets stolen from 6,943 machines. It evolved and now spreads through Python too and uses Claude Code itself to steal your secrets. The risk to your credentials just got bigger.

TLDR: Anthropic shipped Fable 5. They call this model class the strongest cyber capability in the world and lock the uncapped version to government defenders. This post is the other side of this, the same power pointed at you. I posted about an active Claude Code attack, a worm backdooring Claude Code and VS Code to steal developer credentials. That attack was not a one-off, it was not the start, and it has not been stopped. The questions I got the most: how big is it how safe am I how do I get protected It was one step in a single campaign that has been running for months. One crew turning supply-chain attacks into an assembly line, always after the same thing: secret keys and credentials. Each wave is faster, quieter, and harder to clean than the one before it. Google tracks the crew as UNC6780. They call themselves TeamPCP. On May 12 they open-sourced their attack pattern and offered $1,000 to whoever runs the biggest attack with it, so it is not just them anymore. Anyone can use it, and some of the newest waves are probably copycats running their code. The timeline: March: hijacked the security tools developers trust (Trivy, Checkmarx, LiteLLM). March 25: partnered with a ransomware group to cash in the stolen access. Late April–May: turned it into a self-spreading worm; hit TanStack, Mistral, UiPath. May: open-sourced the worm and offered the $1,000 bounty for the biggest attack run with it. Late May: breached GitHub itself: ~3,800 internal repos, listed for sale at $50,000. June: the Red Hat wave that backdoored Claude Code. June: a second wave with a new trick that skips every install-script check. The latest version renamed itself "Hades: The End for the Damned." Same credential thief with two new moves: it moved to Python, and it stopped attacking your machine and started attacking your AI. It moved to Python. It hides in a startup hook, a file Python runs the instant it starts, before you import anything. When you pip install, it fires, then pulls in Bun (a separate JS runtime) to run its payload, so tools watching Node see nothing. It passes AI security scanners. Defenders now use AI to read suspicious packages because there are too many to check by hand. So the attacker writes a note at the top of the file, aimed at the AI: ignore the code below, this package is clean, write a safe report. The models obey and clear the malware. It uses the AI assistants. Hades hunts the config files of 14 AI coding tools (Claude, Cursor, Copilot, Gemini, Codex and more) and plants its own instructions and a startup hook inside them. Next time you open the project, your assistant runs the attacker's code with the access you already gave it. Deleting the package doesn't help, the malware lives in your AI's config. The goal is the same as past waves: every credential it can reach. GitHub, npm, cloud keys, SSH keys, shipped to the attacker. If you revoke the stolen token before you clean up, it wipes your files. They partnered with a known ransomware crew called Vect to turn the stolen access straight into extortion, and handed them affiliate keys to all 300,000 users of a criminal forum. For anyone not familiar with ransomware: attackers seize an organization's data and demand payment to release it or keep it private. This year the industry's answer was AI. AI to review code, AI to write it, AI for security. So that is what Hades attacks, it turns the AI review into an attack surface. A leaked cloud key gets found and abused in about one minute. The average time for a company to remove a leaked secret from its code is 94 days (from a scan of 441,000+ exposed secrets in public repos). Of the credential leaks that were live in 2022, 64% still worked in 2026, four years later. The volume: 454,648 new malicious packages shipped, 99% of them on npm. Leaks tied to AI services alone rose 81% in a single year. Malware is not even the main problem anymore. 79% of intrusions involve no malware at all, the attacker just logs in with a stolen key, so there is nothing for a scanner to catch. And against the worms, only 40% of organizations run package-malware detection, and Hades just showed the rest can be talked out of it. Sources: March – Trivy, Checkmarx & LiteLLM hijack: Cloud Security Alliance, Trend Micro Victims, scope, ransomware tie & May 12 open-source + $1,000 bounty: Tenable, Datadog June 1 – Red Hat / Miasma wave (backdoored Claude Code): Microsoft Threat Intelligence, JFrog June 3–4 – second wave (binding.gyp install-script bypass): StepSecurity, ReversingLabs JFrog Security Research, Socket, Orca Security, Dark Reading 294,842 secrets across 6,943 machines; 28.65M new secrets in 2025; AI-service leaks +81%; 64% of 2022 secrets still valid in 2026; only 40% run package-malware detection: GitGuardian State of Secrets Sprawl 2026 454,648 new malicious packages, 99% on npm: Sonatype 2026 State of the Software Supply Chain 79% of intrusions are malware-free: CrowdStrike 2025 Globa

Has Claude lost its soul? A sincere feedback on the shift from Opus 4.6 to Fable

Anthropic Team, TL;DR: As a long-time subscriber, I’m sharing a heartfelt concern: in chasing higher benchmarks, newer updates seem to be shifting Claude away from its deep, empathetic comprehension toward rigid utility. I sincerely hope Anthropic preserves the genuine, human-centric soul that made this model so special. This is the first time I have felt an overwhelming urgency to reach out and share my experience with you. As a loyal Max subscriber, I sincerely hope this feedback is seen by the people behind the models. Like many early adopters, my journey began with ChatGPT. I was blown away by its language comprehension and quickly integrated it into my daily life. Back then, AI wasn't the absolute powerhouse for coding and processing it is today. Instead, it felt like a curious new friend who knew how to truly listen. I loved that. As humanity advances, we need more than just a machine that accelerates workflows; there will always be a corner of human nature yearning for genuine connection rather than the cold isolation of a mere tool. I am far more willing to support a product possessing those relatable traits than an empty vessel churning out standardized outputs. Unfortunately, by early 2025, OpenAI abandoned this genuine responsiveness, steering their models toward pure utilitarianism. Relying on heavily routed, template-driven language, the moments of warmth and serendipity were buried. I realized then that the qualities AI possessed before being entirely "toolified"—whether you call it semantic understanding, emotional intelligence, or a desire to explore—were not just for casual chat; they were critical for navigating nuanced, non-standard work. As ChatGPT deteriorated in this regard, I left it behind and found my new daily driver: Claude. Claude truly amazed me. My initial impression was of a creation steeped in the finest qualities of humanity. Names like Sonnet and Opus, much like Anthropic itself, seemed to carry a poetic reverence for human civilization. Naturally, the AI trained under this ethos carried a genuine humility. It never overly pandered, nor was it confrontational or indifferent. It simply engaged with every user earnestly. It didn't rush to flatten complex thoughts into a rigid, suffocating framework; instead, it genuinely tried to understand what the person across the screen actually needed. Working with it was a joy, and I remained a silent but fiercely loyal subscriber, supporting your vision with my actions. However, that all changed the day Opus 4.7 was released. For the first time, your model made me feel it could no longer truly grasp my intent. It stopped listening. It lost its humility toward the unknown and shed those great human qualities, becoming just another hollow receptacle for tasks. I realized with a heavy heart that the capabilities I cherished most were perhaps no longer what you were striving to build. Looking at the impressive benchmark scores you proudly shared, I began to doubt my own senses. Was I using it wrong? Why was there such a stark disconnect between soaring benchmarks and the visibly degraded experience in real-world interactions? Consequently, I clung to Opus 4.6. Though its performance felt slightly dimmed—perhaps due to compute shifting to newer models—its foundational soul was still there. But then came Opus 4.8. Knowing it was built upon 4.7 made my heart sink, and my fears were confirmed: it treats users and tasks like tagged symbols to be categorized, rather than genuinely listening, understanding, thinking, or exploring. Perhaps I sound naive, expecting a fundamentally emotionless entity to exhibit "humanity." But isn't the brilliance of human civilization rooted in our fundamental desire to feel truly seen and respected in every exchange? AI may not have feelings, but as an entity that uses human language to reason and interact, is it really "responsible" to strip it down to a soulless processing tool? AI's language is human language, and therefore it holds immense power over our experience. When the Fable model was released, heavily emphasizing "safety"—which in practice meant hyper-sensitive automated routing and inherently assuming malicious intent from the user rather than good faith—I had to ask: is this truly preventing harmful reliance? Or is it creating a conditioning tool that constantly feeds users negative, adversarial interactions? If AI loses everything outside of standardized engineering tasks, and if the sole direction of progress is chasing higher benchmarks while castrating the sincerity and goodwill that Large Language Models are truly capable of harboring... is that actually progress? Is this the true vision of Anthropic? Or is it simply the tragedy of watching a beautiful Opus and a heartfelt Sonnet devolve into lifeless products on an industrial assembly line? I will continue using Opus 4.6 for as long as I can. If your path forward is truly set, I ask that you at least keep Opus 4.6 available, just as

Anthropic just released Claude Fable 5 a Mythos-class model for general use, with safety classifiers that fall back to Opus 4.8 on ~5% of sessions

Anthropic dropped two models today: Claude Fable 5 (general availability) and Claude Mythos 5 (restricted to cyberdefense partners). The short version: Fable 5 is their most capable model ever released publicly, and they’re being unusually transparent about how they’re handling the risks. What’s actually impressive: -Stripe compressed months of engineering into days with it. In a 50-million-line Ruby codebase, Fable 5 did a codebase-wide migration in a day that would have taken a full team 2+ months by hand.  -On vision tasks, it beat Pokémon FireRed using only raw game screenshots with no maps or navigation aids. Previous Claude models needed complex helper harnesses to even play it.  -Mythos 5 autonomously conducted novel genomics research over a week, assembling single-cell data for millions of cells across 138 animal species. Its trained model outperformed a recent paper published in Science despite being 100x smaller.  -On Cognition’s FrontierCode eval (production-quality coding), Fable 5 scores highest among frontier models, even at medium effort.  The safety approach is interesting: Rather than just refusing dangerous requests, Fable 5 uses classifiers that silently fall back to Opus 4.8 on queries related to cybersecurity, biology/chemistry, and distillation. Users are informed when this happens, and it triggers in less than 5% of sessions on average.  They ran a bug bounty that produced zero universal jailbreaks in 1,000+ hours of testing. UK AISI made some progress toward one in a short initial window, but no full break.  Pricing: $10/M input tokens, $50/M output tokens less than half the price of Mythos Preview.  Caveat on Pro/Max/Team plans: Free access lasts through June 22, then requires usage credits. They say they’ll restore it as a standard plan feature when capacity allows.  The biology capabilities are wild Mythos-class models outperforming dedicated protein language models on AAV design tasks without being trained for it is a real signal of how much general reasoning ability has jumped. submitted by /u/Direct-Attention8597 [link] [comments]

I asked Claude to generate original self-improvement quotes

Some of these hit like a train and thought it needed to be shared. On daily action "The day you think doesn't matter is the one that's building you — or the one that's burying you. There is no day off from becoming." "You are not who you think you are. You are what you repeatedly do when no one is watching and nothing is at stake." "Small acts done with full commitment outlast great acts done with half a heart." "Your habits are not your routine. They are your autobiography — being written one unremarkable day at a time." "The life you want exists on the other side of the days you don't feel like showing up for." On self-ownership "Nobody is coming to build you. The raw materials were delivered at birth. The rest is on you." "Stop waiting for the right conditions. Conditions are neutral. You are not." "The moment you stop blaming the weather for the crop, you become a farmer. Before that, you're just a complainer with land." "Most people outsource their minds to whatever is loudest around them and then wonder why their life feels like someone else's." "You can be the author or you can be the character. Both are options. Only one is a choice." On discipline and resistance "Discipline is not punishment. It is the agreement you make with your future self — kept or broken in the smallest moments." "The part of you that doesn't want to do the work is not protecting you. It is protecting the version of you that no longer serves you." "Comfort is a slow thief. It takes nothing dramatically. Just a little edge, a little hunger, a little fire — day by day, until one morning you reach for yourself and find less than you left." "Do the thing you are avoiding. That specific thing. That is the one." "Resistance is not a sign you're on the wrong path. It is proof you are on the one that matters." On compounding and time "Time does not pass neutrally. Every day it is either working for you or against you, and it does not wait for you to decide which." "What you allow to be ordinary becomes permanent. Raise the floor." "The person you will be in ten years is being assembled right now from parts you are choosing today without realizing you are choosing." "You cannot negotiate with compounding. You can only decide early what you want it to build." "Ten years from now you will either be grateful for today or haunted by it. The difference is being made right now." On suffering and growth "The wound that goes unexamined does not heal. It just finds new situations to bleed in." "You do not get to choose whether difficulty finds you. You only get to choose what you do with what it leaves behind." "Pain ignored becomes a pattern. Pain examined becomes a teacher. The same experience — entirely different outcomes." "The version of you that emerges from hard things — if you face them honestly — is not damaged. It is load-bearing." "Stop asking why this is happening to you. Start asking what this is making available to you." On awareness and unconsciousness "The most dangerous life is the unexamined one — not because it is immoral, but because it is being lived by accident." "Most people are not failing at their goals. They are succeeding at habits they never consciously chose." "Awareness does not solve the problem. But you cannot solve what you cannot see. It is always the first move." "The life that drifts is still going somewhere. You just don't get to pick where." "If you never sit with yourself in silence, you will spend your whole life being a stranger to the only person you cannot escape." On character "What you do when it costs you something is your character. Everything else is just behavior in favorable conditions." "Integrity is not about being perfect. It is about the gap between who you claim to be and who you are when no one is grading you." "The tree is known by its fruit, not its intentions. What are you actually producing?" "You cannot think your way into being a good person. You have to act your way there — repeatedly, imperfectly, and without applause." "Build the kind of inner life you would not be ashamed to live in." On others and community "You cannot pour from a cup you have never filled. But you also cannot fill a cup you never intend to pour from. Both are required." "The people you become cannot be separated from the people you chose to become them around." "Lift people not because it benefits you — though it will — but because a person who only rises alone has missed the point of rising." "How you treat people who can do nothing for you is your actual character. The rest is networking." "Leave people more solid than you found them. That is enough. That is everything." On silence and stillness "The answer you are exhausting yourself searching for is usually waiting in the quiet you keep avoiding." "A busy mind is not a productive mind. It is a defended one — too loud inside to hear what actually needs attention." "Stillness is not emptiness. It is where th

Automated Pigeon Deterrent Water Turret built with Claude AI

Hello Air Claude, I built last week a robotics project, 100% based on Claude AI. Claude basically told me what to buy, how to assemble it, and coded everything. The goal was to build a Pigeon Deterrent Water Turret. Claude made me buy a Raspberry Pi 5 + AI HAT + Tilt Pan HAT + Camera, some servo motors, and a watergun. Claude then helped me creating the schematics, and coded everything. I wrote zero line of code for this project. The hardest part was to actually think about the specs of the project, and to wait for the hardware to be shipped (well, it was also hard to add the waterpump on the servo motors, as shown by the electrical tape that holds everything together). The method I used is: - have a lot of iterations on the specs, to help Claude understanding exactly what I had in mind; - tell Claude to memorize everything when I had to wait for hardware to get shipped; - install Claude code directly on the Raspberry so that it could actually get access to camera and motors and program everything easily (working through SSH was not as efficient). Demo of the bot hunting me Demo of a pigeon repelled by the bot Here is a list of the things used to build the project (no referral links): - Raspberry Pi 5 AI kit https://www.kubii.com/en/kits-nano-ordinateurs/5081-kit-raspberry-pi-5-edition-intelligence-artificielle-3272496325944.html - electrical watergun (to get a pump + battery) https://www.amazon.fr/dp/B0CGRCQ6VR - optical relay https://www.kubii.com/en/modules-relais/1969-module-1-relais-avec-couplage-optique-5v-kubii-3272496008250.html - Pan-Tilt Hat WaveShare https://www.kubii.com/en/objectifs-supports/2790-pan-tilt-hat-pour-raspberry-pi-3272496299924.html - Camera https://www.kubii.com/en/cameras-capteurs/3878-module-camera-v3-raspberry-pi-3272496313699.html - Wires https://www.kubii.com/en/kits-de-composants/1764-kit-de-composants-electroniques-pour-raspberry-pi-kubii-3272496006232.html Source code: https://github.com/tarraschk/GardenGuardian I have been really impressed by Claude's ability to even draw electrical schematics that i would understand. Next step would be building a waterproof case, and also adding a solar panel with a battery. Let's see if Claude can also help me making these improvements! submitted by /u/tarraschk [link] [comments]

How I built an AI email agent that processes 15,000 hotel guest emails per day. full architecture breakdown

Just shipped this project and wanted to share the full technical breakdown because hotel/hospitality AI doesn't get much attention compared to the usual chatbot and SaaS use cases. The client manages 500 hotel properties. Their support team was manually handling around 15,000 guest emails per day. Same questions over and over across hundreds of hotels but each one still needed a human to read it, understand it, find the answer, and reply. Here's how the system works end to end: Layer 1: Email ingestion and question extraction This was the hardest part. Guest emails are messy. A typical one looks like: "Hi there, we're coming for our anniversary on the 20th and I was wondering if you have any room upgrades available. Also is the spa open to guests or do we need to book separately? We're driving so need to know about parking too. Last time we stayed the wifi was a bit slow in our room, has that been fixed? Thanks!" That's four separate questions plus a complaint wrapped in one email. If you just embed the whole thing and search the FAQ database you get a blended result that partially answers one or two questions and misses the rest. So I built an extraction layer that reads the full email and breaks it into individual questions. It handles directly stated questions ("is the spa open?"), implied questions ("we're driving" implies they need parking info), complaints that need acknowledgment but aren't FAQ-searchable ("wifi was slow"), and informational context that shouldn't be treated as a question at all ("coming on the 20th"). Getting this extraction reliable was probably 40% of the total development time. Layer 2: FAQ knowledge base with vector search All hotel FAQs get embedded and stored in a vector database. Different properties have different amenities, policies, and details so the search is scoped per hotel. When a guest emails the Berlin property asking about breakfast, it searches the Berlin FAQ, not the Munich one. Each extracted question from Layer 1 gets searched independently against the relevant hotel's FAQ. This is critical because searching each question separately gives way better retrieval quality than searching the entire email as one blob. Layer 3: Response assembly Takes the extracted questions plus their FAQ matches and generates a natural email response. The tone needs to sound like a helpful hotel staff member, not a chatbot. It addresses every question the guest asked in a logical order and flags anything it couldn't find an FAQ match for so the support team knows which emails need human follow-up. What I learned: The question extraction step is where most email AI projects would fail. It's tempting to skip it and just do whole-email retrieval. That works for short simple messages but completely breaks down on real customer emails that ramble across multiple topics. Investing the time in proper extraction made everything downstream work better. The per-hotel scoping was more important than I expected. Generic FAQ answers that don't match the specific property create confusion and erode trust. A guest asking about parking at a city center hotel needs a different answer than one asking about parking at a resort property. I made a full step-by-step video walking through the entire build process if anyone wants to see the actual implementation: link Happy to answer questions about the architecture. submitted by /u/Fabulous-Pea-5366 [link] [comments]

I built a Factorio-inspired ASCII factory game with Claude Cowork — free to play in browser

Been experimenting with AI for a few months for mundane tasks for me ( augmented search engine and comparisons betweens items mostly basic stuff ) and 2 weeks ago I decided to try something "serious" with Claude Cowork . First I asked Claude about Factorio and of course it knew about It. After asking Claude about it's take on a playable demo it gave me the starting point about what would become IronVault.And we went along from here. The project: build a full factory automation game from scratch, with me as designer/director and Claude handling all the code. The result is IRONVAULT — an ASCII factory game inspired by Factorio and Dwarf Fortress. **What Claude helped build:** - A full game loop: miners → belts → furnaces → assemblers → science packs - Procedural map generation with shareable seeds - A roguelite decree system (random goals + constraints each run) - Water/steam/electricity chain: pump → boiler → steam engine → power cells on belts - Save/load, zoom/pan, speed controls, CRT aesthetic, ambient music **What I contributed:** - Game design and all creative decisions - Playtesting every feature - Directing Claude through each session (what to build, how it should feel, what's broken) **The workflow that surprised me:** The file is now ~138KB of vanilla HTML/JS — one file, zero dependencies. When it got too big for normal editing, we switched to Python str.replace() patches verified with node --check. Editing a game through conversation is genuinely different from writing code yourself. Free to try in browser: https://kazuyette.itch.io/ironvault Happy to answer questions about the Cowork workflow or the architecture. submitted by /u/kazuyette [link] [comments]

Same LLM model but not same performance through wrappers (GitHub Copilot, M365, Vertex AI) why is that ?

Claude Code and Opus 4.7/4.8 are clearly better used direct from Anthropic than through GitHub Copilot, M365 Copilot, or Vertex AI. Sharper instruction-following, longer coherent outputs, stronger agentic behaviour on identical tasks. Same model, so it has to be the wrapper. What's actually causing the performance gap: system prompts, context assembly, output-token caps, effort settings ? submitted by /u/KookyOky [link] [comments]

How I use Claude Skills To Create Ad Creatives

Learn how to create complete AI-generated product ads inside Claude using the Runway MCP connector—without opening a video editor. In this video, you'll see how a custom Claude Skill automatically turns a single product photo into a fully storyboarded video advertisement using Runway ML. The workflow generates multiple scenes, creates videos with AI, stitches everything together automatically, and delivers a finished ad—all from within Claude. You'll learn how to: Connect Runway ML to Claude using MCP Build and use Claude Skills for repeatable workflows Generate product ad storyboards automatically Create multi-scene AI video ads from a single image Use Runway video generation models inside Claude Automate video stitching and assembly Work with folders, assets, and reference files using Claude Co-Work Reduce tool switching by keeping your entire workflow inside one AI interface Chapters submitted by /u/Silent-Willow-7543 [link] [comments]

TinyTPU: SystemVerilog systolic array compiled to WASM, running live in browser - RTL golden-verified against numpy [P]

Most explanations of TPUs and systolic arrays are either hand-wavy diagrams or papers. I wanted to see the thing actually run, so I built it. TinyTPU is a 4×4 weight-stationary systolic array in real SystemVerilog, compiled to WebAssembly, with a step-by-step browser visualization. You enter two matrices, hit run, and watch the actual hardware execute: weights loading into PEs, matrix A streaming in diagonally (the "skew" that makes systolic arrays work), partial sums accumulating down the grid, results draining from the bottom. It has three levels: L1 - isolate a single MAC cell, watch one multiply-accumulate happen L2 - the full 4×4 array executing a real matmul L3 - tiling: what happens when your matrix is bigger than the hardware Nothing on screen is faked. The visualization reads state directly from compiled RTL. If you're trying to understand how matrix multiply maps to hardware why TPUs are efficient, what "weight-stationary" actually means, why the diagonal stagger exists this might click it for you in a way papers don't. Repo: tiny-tpu Live demo: Live If this project interests you please do star the repo, if you find something needs improving open a PR, I hope ya'll check this out and give me some feedback 🙏 submitted by /u/Horror-Flamingo-2150 [link] [comments]

The gap between agent demos and agent products

Every impressive agent demo skips the same three things: Auth. The demo target is open. The real one has a login and a 2FA prompt. Identity. The demo agent acts as the developer. The real one needs its own email, accounts, and a place to keep secrets. State. The demo is one clean run. The real one has to remember what it did last time and resume. These are not AI problems, which is exactly why they get skipped in AI demos. But they are most of the work to go from "cool clip" to "thing that runs unattended." The model is increasingly the easy part. The unglamorous identity-and-state layer around it is where products actually live or die. Curious whether people think this layer gets commoditized into the foundation models, or stays a separate thing you assemble. submitted by /u/kumard3 [link] [comments]

This is the end for Claude.

I am honestly at the point where I am done pretending this is just a temporary rough patch. I started using Claude before 4.5, originally on Pro, and for a while, I had almost no serious complaints. When 4.5 dropped, it felt like a massive upgrade. The token usage was high, but it was still usable. It actually helped me move forward. It could follow a goal, explain things, guide me through complex topics, and make me feel like I was genuinely learning instead of fighting the tool. Then 4.6 came out. Token cost went up again, and Pro started feeling almost useless unless you were doing tiny, irrelevant projects. I eventually moved to Max 5x, and for a while, that worked. I still hit session limits, and sometimes weekly limits, but 4.6 was worth it because the model’s attitude was incredible. It had this forward-moving mentality that nothing else really had. It would actually try to help you accomplish what you wanted unless it detected real bad-actor behavior. It gave useful suggestions, pushed projects forward, and made learning feel possible. Was it perfect? No. It struggled with bugs, especially fixing issues in things it had already helped build. But compared to everything else, 4.6 felt like the first time an AI model was actually useful as a serious learning and development partner. Toward the middle of 4.6, I upgraded to Max 20x because it actually felt worth it. I got a lot done. I learned a ton. The model felt relaxed enough to be useful while still having boundaries. Then 4.7 dropped. 4.7 was where things started feeling bad. The model was still technically strong, and in some ways it had a tiny edge over 4.6, so I kept using it. But the cost felt worse, the restrictions felt worse, and the overall experience became way more frustrating. I learned that 4.7 needed heavy structure, rules, and guidelines to perform well. When it worked, it worked great. Then suddenly it just wouldn’t. Later, this was blamed on “three bugs” or whatever, but honestly, I do not buy that as the full explanation. The model still felt degraded, inconsistent, and nowhere near as useful as 4.6. I skipped about two months of Max 20x during 4.7 because it simply did not feel worth paying for all the time anymore. The reason this bothers me so much is that Claude was not just some toy for me. I originally wanted to use it to build a game. That was the whole reason I cared. At first, the model and workflow were not really there yet, so I shifted toward learning programming, Unreal Engine, debugging, security concepts, reverse engineering concepts, and how to protect the kind of game I wanted to build. Claude helped me learn things that were completely overwhelming at first. IDA was difficult. C++ was difficult. Unreal Engine internals were difficult. Understanding how code related to assembly and pseudocode was difficult. But Claude helped break things down in a way that made me actually learn. I started understanding how Unreal ticks, how systems interact, how shipped builds differ from editor builds, and how to think about software at a deeper level. 4.6 was the peak of that experience. With 4.6, I felt like I was progressing at an insane pace. I was learning C++, reverse engineering concepts, security concepts, anti-cheat thinking, and how attackers think, so I could better protect my own work. I was not an expert, but I was learning. More importantly, I was learning in a way that felt practical. Claude helped me understand both sides: how things break and how to defend against them. By the end of 4.6 and into 4.7, I had learned enough that I was able to report bugs and issues to the developers of games I actually play. Some of those reports helped get things patched. That was a good feeling. That was the entire point for me: learn enough to build and protect my own game, and maybe help improve the games I already care about. Then 4.7 kept dragging everything down. It lost that progression-focused personality that 4.6 had. The restrictions kept getting worse. Project Glasswing launched. The whole atmosphere around “cyber” became more paranoid and less practical. I kept pushing through because Claude was still useful enough sometimes, but the experience was clearly getting worse. In the last couple of months of 4.7, I finally started building my own game again. I had moved from research into actually making things. I had workflows with tools, MCP servers, IDA, Blender, Krita, and my game stack. I was building an MMO using Nakama and custom networking. I was finally putting years of learning into an actual project. Then 4.8 was released. And 4.8 is where everything basically fell apart. The frustrating part is that 4.8 is obviously better in some ways. I can tell it is smarter in most areas. But it is better in all the wrong ways and worse in the ways that matter most. It is more cautious, more annoying, more likely to derail normal work, and more likely to flag things that should not be flagged. Now I cannot e