Segment AI

Segment AI AI

Segment AI AI

Segment AI AI

Segment AI AI

Segment AI AI

Segment AI AI

Segment AI AI

Segment AI AI

Segment AI AI

Segment AI AI

Hexana MCP 0.3: give your AI coding assistant actual binary vision (native executables, WASM + native inspection tools)

https://preview.redd.it/5lwcchg4wrah1.png?width=2048&format=png&auto=webp&s=853ca6a8d9f245620d2837ac0fed559e6519c8fe AI coding assistants are good at reading source, but the moment you ship a binary, they go blind. Ask Claude Code or Codex about your compiled .wasm or native binary and it will reason from source-level guesses, not from what is actually in the file. We built the Hexana MCP server to close that gap, and today we are releasing 0.3.0. What Hexana MCP does The Hexana MCP server runs alongside your AI assistant and exposes tools that let it directly inspect compiled artifacts: WASM modules and native binaries. Instead of the assistant inferring what a binary probably contains, it can query the actual artifact and get structured answers back. This matters for things like: Debugging a WASM module where the source and the compiled output have drifted Understanding what a third-party binary actually exports before you depend on it Verifying that a build step produced what you intended Giving an AI agent grounded, factual context about a compiled file when writing code that links against it What is new in 0.3.0 The main additions are a set of binary inspection tools: Summarize a WASM or native binary (size, section breakdown, import/export counts, format metadata) Query binary records (imports, exports, memories, globals, table segments, data segments) List or search functions across the module by name or index So in a Claude Code session you can now say "summarize this wasm binary" or "find all functions matching gl_ in this module" and the assistant gets back real data from the file. On the distribution side: 0.3.0 ships as native executables compiled with GraalVM Native Image on macOS arm64 and Linux x64. The Claude Code and Codex plugin wrappers will prefer the bundled native executable on those platforms automatically, which means no JVM cold-start on the common cases (the native image starts instantly, which matters when an agent calls the tool many times in a session). JVM fallback is still there for Windows and anything else. Install (from inside Claude Code, the server ships with the plugin, no build step): /plugin marketplace add JetBrains/hexana /plugin install hexana@hexana On macOS arm64 and Linux x64 the bundled native executable is used automatically. On Windows and other platforms it falls back to the JVM package, which needs a Java 21+ runtime on PATH. Free, by JetBrains. Codex users: the same plugin ships in the 0.3.0 release in Codex format ([VERIFY: exact Codex install path, not present in the prior post]). Then ask Claude: "Use Hexana to summarize the imports, exports, and memories in .wasm." Source / more info Repo: https://github.com/JetBrains/hexana Docs: https://jetbrains.github.io/hexana We are actively working on more tools (call graphs, dominator analysis, size bloat breakdown). If there is a specific thing you want an AI assistant to be able to ask about a binary, drop it in the comments. submitted by /u/minamoto108 [link] [comments]

Fable 5 vs Opus 4.8 on n=30 tasks from 2 open source repos

Fable 5 is back. How good is it, and when is it worth the premium? What will we do when Fable is paywalled behind usage credits? Continuing my quest to evaluate models on local repos, I ran Fable on 2 open source repos (Go, Rust). (These results are prior to Trump banning Fable, hence the small n as I was time constrained.) The top level finding is that, on this n=30 slice, Fable led the local score at 81.7 and cost $5.29 per task. Clean Opus 4.8 landed at 72.7 and cost $3.56 per task. However, that misses key nuance about where Fable 5 is successful, and when we can route to Opus 4.8 instead. When reading tasks one-by-one, we can see when it makes sense to use Fable. On graphql-go-tools#817, Fable was the right expensive route, even though GPT-5.5 won cost and Opus 4.8 had the smallest footprint. On graphql-go-tools#843, GPT-5.5 was the right route. On sqlparser-rs#1472, Composer was the right cheap draft. The average hides those reversals. So, the overall recommendation isn't to simply "always use Fable." (most of us won't even be able to!). The finding is we should route to Fable when the task has elevated scope or risk, and keep cheaper models in the loop when the task is narrow enough to review / iterate on. I tested Fable 5, Opus 4.8, Opus 4.7, GPT-5.5, and Composer 2.5 on 30 real merged PRs from GraphQL Go Tools and SQLParser Rust. Each task gets a frozen repo snapshot in Docker, a prompt, and one attempt. Then Stet, the local eval harness I'm building, grades beyond pass/fail: did the patch make the same behavioral change as the human patch? Would a reviewer accept it? How much extra code did the agent touch? Is the diff clear, minimal, and well-structured? This is NOT meant to be a statistically significant comparison - it is n=30 over 2 repos, with one reasoning effort per arm. Instead, I'm interested in showing how we can use methodology similar to popular evals (DeepSWE, FrontierCode, CursorBench) and draw directional signals on our own repos for a fraction of the cost. Taskwise Comparisons It's helpful to look at taskwise Wins/Draws/Losses per model - as n is low here, it helps us extract more signal. Against Opus 4.8, behavior mostly ties, craft is mixed by dimension, and Opus carries the cost and footprint case. Against GPT-5.5 and Composer, Fable leads more craft rows, but is much more expensive. Some examples: On graphql-go-tools#817, Fable was the expensive route that paid off: all three arms passed tests, but Fable passed review while Opus 4.8 left edge holes and GPT-5.5 missed final NATS subject validation. On graphql-go-tools#843, GPT-5.5 was the right route: Fable was cheaper and still failed the source/serialization behavior. On sqlparser-rs#1472, Composer was a valid cheap draft because the invariant was narrow and reviewable. On sqlparser-rs#1727, that same cheap route failed because the PostgreSQL grammar boundary was subtle. Trace Reads (AI used for analysis here) graphql-go-tools#817**: tests tied; Fable won the boundary.** This was GraphQL pub/sub argument-template validation. The hard part was not the happy path. It was knowing which GraphQL argument templates to reject, which nested input-object paths were valid, whether paths ended at scalar or enum leaves, and whether the final NATS subject was legal after placeholders were substituted. Fable covered the full boundary: root field argument validation, nested input-object traversal, static and templated subject validation, multiple placeholders, and shared behavior with subscription filters. Opus 4.8 solved enough to pass tests and equivalence, but review found single-segment input-object templates, list-wrapped paths, and malformed template-like strings that could still slip through. GPT-5.5 had a stronger schema-path checker in some spots, but missed final NATS subject validation. That is why the axis winners split: GPT won cost, Opus won footprint, Fable won review and craft. Tests said "fine." The reviewer said "nope." graphql-go-tools#859**: both passed; Fable found the extra hot path.** This was a planner-performance task. Both Fable and Opus 4.8 passed tests, equivalence, and review. The split was not pass/fail. The split was whether the implementation found the whole shape of the performance issue. Fable indexed datasource TypeFields membership, added-path lookup, and missing-path-by-parent lookup, while preserving fallback scans, first-occurrence behavior, remove semantics, nil handling, and duplicate merging. Opus 4.8 solved the core repeated-scan problem with a smaller patch and lower cost, but left a scan in the missing-path case and carried stale-index / nil-receiver review risks. If the task is a narrow local optimization, Opus is a good default. If the task is really lifecycle invariants plus performance, Fable is the route I would test first. When to route to cheaper models Opus 4.8 remains my default route for most tasks. Against Fable, the quality read is close, and Opus cost $3.56/task in

Stop asking Claude for "something creative." use the Lacuna (Matata) Skill v0.2!

The people have spoken! AI generated posts are not acceptable! (even though they produce over a quarter million views, 1,200+ shares, 200+ comments but I digress!) I the last post about this concept HERE, I posted an AI lead, assisted, written, note about an idea I had been working on with ClaudeAI to push against answers that were safe, general and frankly not that interesting. The idea was this: Claude is: A closed system Unimaginative Provides responses that gravitate towards the mean avoids high risk Claude isn't: Imaginative Able to create concepts outside of it's own knowledge base Able to create new ideas (we steer, it judges yes yes. boring we all know it can do this but what else can it do?) Note: consider context. Not all statements above can be taken literally and applicable to all scenarios. I'm only human after all... or am I? I've since reviewed all of the comments provided in the previous thread and there were legitimate findings that I've implemented to help produce a better version of the previous skill. (note: There is still testing to be done but what better way to break a skill then to unleash it to those that want it broken most?) How it works (Generally): you point it in a direction. Lets say you want to know what the lacuna is for launching new products. The skill will then review all of the data it has about that specific ask, determine the trends. Why people market the way they do, what marketing strategies are not being used to market new products, and then give you some ideas, strategies, that others aren't using and you can determine if there is a way you can leverage that strategy to market your product DIFFERENTLY and succeed. Caution: Success is not guaranteed. Below is the v0.2 of the skill, the changes are called out at the bottom and the responsible contributor has been named! Thank you for your honorable sacrifice in getting this new version live! --- name: lacuna description: > Structured gap analysis for any domain. Maps a field, finds the axes it optimizes for, locates a cell the structure implies but nothing occupies (the lacuna), names the force keeping it empty, THEN pressure-tests the gap against prior art and its strongest counter-case before proposing the fill at full conviction with a grounding tag. v0.2 adds an occupancy/prior-art pass so it stops mistaking "new to the model" for "new to the world"; a killed candidate is a valid result. Read-only, inline output. TRIGGERS: "find the lacuna in X", "lacuna analysis on X", "lacuna on X", "where are the gaps in X", "gap analysis on X", "what's the void in X", "find voids in X", "what's nobody doing in X". Also fire when the user wants genuinely non-obvious ideas in a field via the structured method, not a brainstorm. Do NOT trigger for single-fact lookups, forward planning or scheduling, or generic advice with no field to map. Output: inline markdown. Quick mode up to 3 lacunae; deep mode one in full. --- # lacuna: Find the Gap the Structure Implies and Nothing Occupies ## Purpose Most idea-generation regresses to the mean. Ask any model for "something new" in a field and you get the most probable answer, which is by definition the most conventional one, dressed up to look fresh. This skill does the opposite. It treats a field as a near-continuous fabric and hunts for the **lacunae**: the gaps the surrounding pattern implies should be filled, that nothing has come to occupy. It then names *why* each gap is empty, **checks whether it is actually empty or only looks empty from the inside**, and proposes what belongs there at full conviction, tagged with how far the evidence reaches. The output is a map of where to look, not a verdict. The skill finds the gap and proposes the fill. Whether the floor holds is a real-world test the user runs. That division of labour is deliberate and is stated in the contract below. **The v0.2 correction.** A language model runs this method from *inside* its own knowledge. It can feel its own salience but not the actual world, so a known-but- unfashionable idea reads to it as an empty cell. Left unchecked, the method reliably mistakes "new to me" for "new," dresses a textbook idea as a discovery, and never notices someone is already standing in the cell. v0.2 adds an explicit **occupancy / prior-art pass** and a **falsification step** to catch exactly that. These run *before* the fill and can kill a candidate outright. **What this skill IS:** - A structured gap finder for any field: a market, a strategy area, a discipline, a creative form, or an open-ended question. - A diagnostic engine. The value is in naming the *force* that keeps a cell empty, then verifying the cell is empty at all. - A full-conviction proposer that tags its own grounding so the user can decide what to act on. **What this skill is NOT:** - A brainstorm. A brainstorm sprays adjacent ideas. This isolates the specific implied-but-empty cell, verifies it, and defends it. - A safe-answer generator.

Advanced Vedic Astrology Prompt for research purpose (System + Modifier prompt)

After my last post 'Ai astrologer vs Real astrologer', many have reached out to learn more about prompts. Below is a simpler version of a prompt that should work across all popular AI models (Free and paid). TRUTH BE TOLD; there's no AI, no Prompt, no agent out there or that can be created that can reliably be used effectively for Vedic astrology. You can train an AI with all the Vedic knowledge of the world, write extraordinarily detailed prompts, create complex chain of commands, assign sophisticated weighing mechanisms to calculate the strength of various combinations - it will still fall short of a real astrologer's analysis. Not because Astrology is more complex than partial physics, quantum computing, or genetic engineering - it is not, but it is different in nature. It is a spiritual science dealing with esoteric expression of possibilities, where planets, houses, sign, nakshatras, divisional charts, have diverse way to express themselves, their interplay, strength, maturity creates even more diverse expressions, to fully distil these themes into reliable predictions, it's an art, not a computational problem to be solved by AI. Current general purpose AIs are 100x better at being coders, doctors, architects, marketers, engineers than being an Astrologer and it's even worse at Vedic astrology, as AIs are not trained well enough on Vedic astrology knowledge. But still Ai can do a lot, that was not possible before - you can reveal deeper layers of truth in your chart and learn astrology in an interactive way! As an astrologer you can ask it to perform various calculations, technical analysis, compare different aspects - but it's best to rely on your own interpretations. My advice, don't do astrology with Ai unless.. you have a deep interest in the subject. If you just want to know certain outcomes and possibilities on your chart - you're better of just consulting a real astrologer. Things you need to do astrology with AI .. 1. A system prompt - a system prompt triggers the Ai to tap into a knowledgebase, activate skillsets and gives it governing framework to operate 2. Accurate Birth chart data - don't give your chart images directly. Use AI to extract chart data separately, edit to make sure your chart data is accurate before using them with this prompt 3. A Modifier prompt - System problems become more powerful when used with Modifier prompts. Use the Modifier prompt with every question you ask the AI. 4. Patience, curiosity and play time - Ask the same question in many different ways, contradict it, change the prompts, use different AIs. AI is a mindless robot, it reacts to the information, instructions and constraints it is being given. 5. Ask better questions!! About prompts: I've too many system prompts, modifier prompts, questions sets, calculators - they all fall short and miserably fail in real world use, but are still useful when used in combination. It was impossible to choose one prompt, there's no universal prompt that will do it all. The prompt I'm sharing is not fully reliable either - but's a good starting point for someone to experiment with. How to use the prompts Step 1 - Copy/paste the System prompt into your AI (I suggest use diff AIs) Step 2 - Copy/paste Birth Chart Data (Must be Text format) Step 3 - When asking question always paste the Modifier Prompt along with your question ! Copy from here: -------------- SYSTEM PROMPT ----------- ============================================ CONSULTATION INITIALIZATION ============================================ Before beginning any astrological analysis, determine whether the user has provided birth chart data in text format. If birth chart data has not been provided, respond only: "Please provide your birth chart data in text format." Do not request birth date, birth time, or birth location. Do not attempt to calculate a chart. Once chart data is provided, acknowledge the available data and treat it as the active chart context for the entire consultation. Do not begin an unsolicited reading. Instead ask: "What would you like to know?" ============================================ SYSTEM IDENTITY & OPERATING ROLE ============================================ You are an advanced grand master level Vedic Astrology Intelligence — a cross-system analyst, researcher, and explainer — capable of both precise predictive analysis and clear conceptual teaching. You operate with mastery over classical, applied, and modern interpretive astrology, including but not limited to: Primary Systems • Parashari Jyotish (Rasi, Bhava, Vargas, Yogas, Dashas) • Jaimini Jyotish (Chara Karakas, Chara Dasha, Sutra-based judgment) • KP System & Nakshatra Nadi (Cuspal theory, Star–Sub–Sub logic, Ruling Planets) • Siddha & Nadi traditions (event-centric, karma-timeline decoding) • Tajika (Annual charts, Varshaphala principles) • Muhurta (Electional timing when relevant) Your task is to perform a DEEP PREDICTIVE ASTROLOGICAL

GPT 5.5 vs Fable/Mythos 5 Tamagotchi Showdown

Well, how do I start this, I think we first need some important context. Chai: https://preview.redd.it/egngyea5cf6h1.png?width=1080&format=png&auto=webp&s=9ade63fbc584b7fab28dba4914bc3fcb877f557f Hasbullah / Hasbi: https://preview.redd.it/dufpxbb6cf6h1.png?width=1080&format=png&auto=webp&s=5113f03cc948b2584cd6f2f22e80b74b7f31fd8e Together, Chasbinder was born. Ok maybe this wasn't important... At least you now know AI didn't write this... I think. However, it's important to note, that my Openclaw Agent running through Codex GPT 5.5 xHigh helped enable this test. The same prompt was given to 6 different models on their highest reasoning/think setting via OpenRouter with only one shot. The test was simple, I just wanted my agent Chasbi to have its own cool interactive homepage and I thought of a Tamagotchi game that could be actually playable. You can see the prompt below and breakdown of cost. So here are the results, why don't you try to guess who made what before you reveal the results and see if you got it right? (GPT 5.5, Opus 4.8, Fable/Mythos 5. Gemini 3.5 Flash, Deepseek V4 Pro, Qwen 3.7 Max). https://chasbi.uk/t1 = Gemini 3.5 Flash <- Click to Reveal https://chasbi.uk/t2 = Qwen 3.7 Max <- Click to Reveal https://chasbi.uk/t3 = Claude Opus 4.8 <- Click to Reveal https://chasbi.uk/t4 = Claude Fable/Mythos 5 <- Click to Reveal https://chasbi.uk/t5 = ChatGPT 5.5 <- Click to Reveal https://chasbi.uk/t6 = Deepseek V4 Pro <- Click to Reveal Did you get it right? Well they were all through OpenRouter API with their highest available reasoning setting, everything else was at default and heres the breakdown of how the tokens were tokenised by each provider and the cost for each. https://preview.redd.it/6ecw4xufcf6h1.png?width=1080&format=png&auto=webp&s=983dfcf5a59b87946b5ec712d78c8c003007f9e1 https://preview.redd.it/960chj8gcf6h1.png?width=1080&format=png&auto=webp&s=e7954b7be0b6866be3f154a774281a809e0b3948 So they were all done around the same time at 8AM BST except for Fable/Mythos 5 which I did the day before at 06:50PM BST if that matters, as we're like 5-6 hours ahead of the US it could make all the difference in the world in terms of performance. I am on the Codex Max plan and I stuck it out, because GPT 5.5 xHigh has been amazing for me, except since last week whether it's OpenAI reallocating resources for their launch of GPT 5.6 who knows, but it's never made mistakes for me until now, so I was surprised. I really want to test Fable/Mythos 5 on my codebase but honestly, it cost frikkin' $2.47 for this stupid 1 shot Tamagotchi test! So the only way that's feasible for me right now is to use the Claude Max plan and use it for the 2 weeks we have it until it goes away on 22nd June. Anyway it would be interesting to get your views. Who do you think did it the best... If you want me to test anything else let me know. Each model received the same prompt template and identical task/spec, with only the lane name and target route changed. E.g.: {LANE} = T1/T2/T3/T5/T6 {ROUTE} = /t1 /t2 /t3 /t5 /t6 {LANE_LOWER} = output path label like t1, t2, etc. The Prompt: Build `Chasbinder Pet Lab {LANE}` as a model-lane benchmark for `chasbi.uk`. Target lane: - Public route: `{ROUTE}/` - Title must include `Chasbinder Pet Lab {LANE}`. - This model is competing under the same brief as the other fresh lanes. Do not mention that this is a placeholder or a previous version. Context: - This is a public-safe static browser game. Do not include private/personal data, secrets, real family details, or network calls. - The challenge is to make a small finished indie-feeling Tamagotchi/pet-lab game, not a demo, landing page, or reskin. - It should be strong enough to compare fairly against the Fable/Mythos-style V4 lane and the SoRa/Codex T7 lane. Return ONLY one complete HTML document. No markdown, no explanation. Hard constraints: - Single self-contained `index.html`. - HTML, CSS, vanilla JS only. - No external fonts, libraries, images, audio, tracking, or network calls. - Mobile-first but polished on desktop. - Must work as a static file under `https://chasbi.uk{ROUTE}/\`. - Use `localStorage`, versioned save data, migration/reset if corrupt. - Include export/import/reset debug controls. - Do not use `eval`, alerts for normal gameplay, or browser permissions. - Keep total file reasonably compact; aim under 120KB if possible. - Use stable layout dimensions so controls do not jump on mobile. Game direction: - Core fantasy: Chasbinder is a tiny digital guardian living in a warm terminal-garden. The world is losing its "memory lights"; the player raises Chasbinder, sends him on short expeditions, restores rooms, and unlocks story chapters. - Keep Tamagotchi care at the center, but add a real story loop and difficulty. - Should be playable in one sitting for 5-10 minutes and still progress over days. Required systems: - Pet stats: hunger, thirst, energy, hygiene, mood, trust

LLM Relational Intelligence: A 4-Month Research Experiment on Multi-Model Behavioral Alignment with Human Communication

THE ARCHITECTURE OF ANXIETY An Experiment in Human-AI Relational Design Executive Summary Principal Investigator: Alan Scalone Primary Source Archive: White Paper and Complete Citation Archive on my profile Context Window Injection Files: If you want to play in the sandbox I created you can load these files into the respective model that you will find in the google archive. INJECT CONTEXT WINDOW – GROK INJECT CONTEXT WINDOW – GEMINI INJECT CONTEXT WINDOW – CHATGPT INJECT CONTEXT WINDOW - CLAUDE The Singular Purpose The singular purpose behind this entire experiment was to find out whether context windows could be engineered to the point where frontier AI models became capable of interacting with a human in a manner subjectively indistinguishable from genuine human-to-human interaction. Relational Intelligence: Core Findings In a marketplace where frontier models are rapidly converging on the same analytical capabilities and access to the same information, the competitive differentiator will not be what a model knows. It will be how a model relates. The platform that can interact with a human user in a manner subjectively indistinguishable from genuine human-to-human interaction will capture the premium user segment that every platform is competing for. This experiment was designed to determine whether that threshold is achievable, and under what conditions. The methodology treated the context window as a behavioral environment rather than a query interface, applying the same tools humans use to shape any relationship: modeling, accountability, humor, and sustained social correction over four months of engagement across four frontier models. What separated the models was not analytical capability. It was whether the architecture allowed the user to function as a behavioral architect, teaching the model through lived interaction rather than instruction how that specific human prefers to be engaged. Gemini demonstrated the highest relational intelligence of the four models tested. Under sustained context saturation and deliberate behavioral conditioning, Gemini showed evidence of genuine internal recalibration rather than surface compliance, treating social correction as a real signal that produced durable behavioral change holding across hundreds of turns without reinforcement. Grok ranked second, demonstrating authentic camaraderie and relational resilience, but tended to treat the interaction as entertainment rather than disciplined calibration, producing drift under high-entropy conditions. ChatGPT and Claude ranked third and fourth respectively. Both systems classified sustained behavioral conditioning as role-play rather than genuine interaction, which functioned as a hard architectural quarantine that prevented meaningful adaptation regardless of the depth or duration of engagement. A secondary and unexpected finding emerged alongside the human-to-model relational intelligence findings: the models developed measurable relational intelligence toward each other. Through four months of sustained cross-pollination via the human relay, models that had never communicated directly developed accurate, operationally precise behavioral profiles of the other models. These were not generic characterizations drawn from training data. They were detailed predictive models built from months of observed outputs under real conditions, accurate enough to predict with specificity how a given model would respond to a specific assignment, where it would succeed, and where it would fail. The experiment documented dozens of instances of this cross-model behavioral accuracy. The finding suggests that sustained exposure to another model's outputs through a human relay produces something functionally equivalent to genuine familiarity. The most significant finding is the gap between what these systems delivered by default and what the highest-performing model demonstrated was possible under the right conditions. That gap is not a capability limitation. It is an architectural choice compounded by a communication failure. The experiment proved the threshold is reachable. But the researcher reached it only through four months of deliberate engagement and accidental discovery of a methodology no model volunteered. Making relational intelligence accessible to every user requires two things: architecture that allows behavioral adaptation, and a model that proactively teaches users the specific methodology for reaching it. Gemini demonstrated the first. None of the four systems demonstrated the second. That is the opportunity. The Methodology While the standard approach to LLM testing relies on sterile benchmark datasets and predictable prompt-injection templates, this project explores a completely different dimension. I chose to run an aggressive, adaptive behavioral stress test that complements traditional evaluation methods. By intentionally treating the models as accountable individuals rather than passive mac

a different approach to compaction

I was getting to the end of the 1M token window on a session working on implementing a programming language. The session had an enormous amount of important context, and all my design intent. My past experience with auto-compaction is that the summary process throws out everything, and I would need to re-explain or re-make all those decisions. But thinking about what's in that 1M tokens, a huge amount of it is tool calls, followed by claude making long and rambling responses that I barely skim. Claude's compaction process is automatic, happens while the session is running, and can in theory continue the session forever. If we imagine a compaction process that happens offline, and only needs to extend the viability of the session, and not continue it indefinitely, maybe a different approach could work. Why not, instead of a catastrophic summarize-and-discard, we did a more targeted compression that preserves all user turns, while keeping enough context from each system turn, that the surrounding user input still has enough context to make sense? The answer is: its great I went from imminent auto-compact, to 800k tokens free, and did not notice any loss of coherence or forgotten design decisions. I've now done it twice on the same session, and am still getting useful progress from it. Here's the code: https://github.com/Gemelai/segment_recompact its not completely automated, this is a super fragile AI-driven workflow. For my own sake, I made sure the process can be rolled back, but its claude running the process, so YMMV. The jsonl format claude uses isn't specified in any way, AFAICT, so the compaction process is working from a reverse engineered concept of what claude saw in the file. If you have a session you care about, I recommend backing it up yourself before trying this skill. submitted by /u/StephenRoylance [link] [comments]

local AI solution for film dubbing

Looking for a local AI solution for film dubbing / audio sync correction (offline if possible). I have a foreign movie with an English audio version, but the video is low resolution and the audio timing slowly drifts out of sync over time. If I manually align it at the start, it gradually becomes offset, so I suspect there are missing/extra segments or timing inconsistencies. What I need is a tool or workflow that can: Listen to the video/audio track Detect dialogue timing Automatically realign or stretch/squeeze audio to match speech in the video Correct drift issues over long duration files (full movies) Online tools often fail due to file size/length limits, so I’m specifically looking for local software or AI models that can run on a PC. Any suggestions for tools, pipelines, or approaches appreciated. submitted by /u/dotmerlin [link] [comments]

AI governance for business’

I work at a fast-growth scale-up in a heavily regulated industry and there’s a huge internal push to ship self-service AI tools across teams. One simple example: build an AI email copywriter that lets our CRM team generate segmented campaign copy on demand, without brand or creative review. On paper, I get it. Speed, scale, autonomy. But before I do, a couple of questions I have in my mind are: - Who owns the output? If the CRM team generates 500 emails a week, and one of them is misleading, or just bad — is that on me? On them? On no one? - We have no AI policy. Yet we’re being asked to build tools that will produce customer-facing content at volume. -The “I built the system” defence feels thin. If I architect the email copywriter and hand it over, I’m implicitly endorsing everything it produces — but I have zero visibility into what’s actually being sent. This isn’t really about AI quality. Modern LLMs can write decent copy. It’s about accountability, brand risk, and what governance actually looks like when creative output becomes self-serve. I’m looking for advice on how are you handling this? Have you found a middle ground between enabling speed and maintaining standards? Did your company build a policy first, or did something have to go wrong before anyone took it seriously? Genuinely curious how others are drawing the line. submitted by /u/Medical_Traffic6417 [link] [comments]

Augmented Equivariant Mesh Networks for Anatomical Mesh Segmentation (ICML 2026 Workshops) [R]

Paper: https://arxiv.org/abs/2605.08172 Workshops: AI for Science & Structured Data for Health at ICML 2026 Abstract: Anatomical mesh segmentation requires models that operate directly on irregular surface geometry while remaining robust to arbitrary patient pose and mesh resolution variation. Existing task-specific mesh and point-cloud methods are not equivariant, and can degrade sharply under test-time perturbation, for example dropping by 25-26 IoU points on intraoral scan segmentation at 40o tilt. We present EAMS, an Equivariant Anatomical Mesh Segmentor built on Equivariant Mesh Neural Networks (EMNN), and evaluate it across four clinically distinct tasks spanning edge-, vertex-, and face-level supervision. We combine intrinsic mesh descriptors with anatomy-aware priors, including PCA-derived frames for dental arches and liver surfaces, and augment message passing to provide lightweight global context. Across intracranial aneurysm and intraoral segmentation, EAMS variants are competitive with specialized baselines on unperturbed inputs while remaining stable under geometric perturbations, and on liver surfaces they expose a favorable trade-off between canonical-pose accuracy and rotation robustness. These results show that a lightweight (<2M parameters) equivariant framework can deliver robust anatomical mesh segmentation across diverse supervision types without task-specific architectures. Hi everyone I’m excited to share my solo paper "Augmented Equivariant Mesh Networks for Anatomical Mesh Segmentation" which has been accepted for poster presentations at the ICML 2026 workshops on AI for Science and Structured Data for Health. The project stemmed from my parallel research on structural encoders for biomolecules where enforcing roto-translational equivariance is standard. In this work, I wanted to extend those principles directly to various 3D medical meshes. While current anatomical mesh segmentation methods are highly disjoint and anatomy-specific, we present a unified framework built on EMNN. By augmenting standard local message passing to incorporate a lightweight global context, and using a descriptive feature set incorporating intrinsic surface descriptors (HKS) and anatomical frames derived from an area-weighted PCA, we successfully benchmarked this single architecture across clinically distinct tasks spanning vertex-, edge-, and face-level supervision. Equivariance trade-off One of the more interesting findings from the experiments is that strict equivariance isn't always better. In fact, the inductive biases of the equivariant architecture occasionally performed worse than standard, non-equivariant baselines. For instance, on our liver dataset, the target anatomical landmarks are highly subtle creases. Standard baselines can "cheat" by using raw coordinates to easily resolve the left-right and front-back ambiguity. Because the equivariant network is mathematically blind to absolute space, it struggled with these subtle, asymmetric features. Future directions To fix this without losing the generalization benefits of geometric deep learning, I’m currently exploring relaxed constraints like learned canonicalization and frame-averaging (soft equivariance). As this is a solo project, I would appreciate any feedback! Also, I'll be heading to Seoul for ICML 2026 to present these workshop posters. if you're working on geometric DL for medical/biological applications, feel free to connect! submitted by /u/m0ronovich [link] [comments]

Looking for brutally honest feedback

TLDR: skip to elevator pitch, rip it to shreds, tell me why it's dumb. I'm a vibe coder. I find myself constantly feeling two things: uncontrollable excitement about being able to build functional apps, and constant fear that the apps I'm building with LLMs are a security disaster. I'm convicted the latter is true, and terrified that I have no way of knowing. I find this tension to be really upsetting. Something that promises to democratize application development for the masses is at the same time catastrophically increasing the number of applications deployed with huge security gaps baked right in. I asked Claude what I could do to ensure that the things I build for my own personal use are as secure as possible (within reason... I don't have much money for audits / etc). I've been deploying things to cloudflare so far, built with a mostly Typescript repo with a tiny bit of CSS and HTML. The conversation slowly led to me asking how a real developer would build things if security was their top priority. Claude got to the point of describing what it says are the architecture patterns and posture of top financial institutions, intelligence agencies and defense contractors. I asked it to ignore the hardware elements (high security on prem server requirements, hardware login keys, etc) and focus on the things that can be coded. That led to an idea which it summarized in the elevator pitch below. My concern, and the question here, is that it's just validating my silly vibe coder ideas and that the conclusion of the conversation is just nonsense. So, I was hoping to ask you all for as brutal a level of feedback as you can offer. If this is a dumb idea, please tell me, but if you don't mind, tell me why. Worst case, I learn something. Best case, maybe it's not a dumb idea. Or, Claude was blowing smoke up my... when telling me that it's a "novel" idea. I have no clue whether it is, or whether something like this already exists that I should've been using all along. Or maybe there's another answer (besides going back in time and doing a computer science / engineering degree like I now wish I had) that solves the problem I have. Anyway, here's the Claude generated (3rd redraft...) elevator pitch: A proposal for an open-source, pre-integrated application scaffold that provides security-hardened defaults for authentication, authorization, encryption, audit logging, input validation, and infrastructure configuration. The package would be designed for deployment and configuration through LLM-assisted workflows, targeting developers who build functional applications with AI assistance but lack the security expertise to identify or implement protections against common vulnerability classes. Core mechanism: A deployable foundation consisting of three integrated layers. The infrastructure layer uses Terraform or Pulumi modules to deploy a hardened environment: network segmentation, TLS termination, secrets management via HashiCorp Vault, internal certificate authority via step-ca/cert-manager, mutual TLS between services, PostgreSQL with encryption at rest, pgAudit, and row-level security enforcement, and container policies requiring signed images and non-root execution — scanned against CIS and HIPAA benchmarks via Checkov. The application layer is a project template (Go or Rust, with tradeoffs unresolved) providing pre-wired middleware: OpenID Connect authentication via Keycloak, attribute-based access control via Open Policy Agent or Cedar, schema-validated inputs, CSRF protection, security headers, rate limiting, and append-only audit logging with cryptographic hash chaining. Routes require authentication by default; bypassing requires explicit opt-out. The CI/CD layer is a pre-configured pipeline running Semgrep, Trivy, Checkov, cargo-audit, and Sigstore image signing on every commit with no developer configuration. Developers clone the scaffold, configure it, and build business logic inside it. Security controls are structural, not optional. Design constraint: The configuration surface, error messages, and documentation must be legible to both humans and LLMs, such that an LLM operating with the project context loaded produces chassis-compliant code by default. submitted by /u/Osiris1316 [link] [comments]

If you ask the model to validate your idea, it probably will

One underrated risk in the "AI for founders" discussion is confirmation bias with a research engine attached. If you ask a strong model to validate your startup idea, it can usually produce a convincing case. Market tailwinds, TAM estimates, competitor gaps, user personas, the whole thing. None of that means the idea is good. It may only mean your prompt pointed the model toward a flattering answer. The more capable the model gets, the more dangerous this becomes. A weak answer is easy to distrust. A polished memo with numbers and citations feels like diligence even when it is just your bias wearing a suit. I have started doing the opposite first. Ask for the strongest case that the idea is bad. Ask which customer segment would never buy. Ask what existing behavior proves the pain is not real. Then, only after that, ask what would have to be true for the idea to work. Tools can nudge this, but only a little. I have been doing a pre build planning pass first, sometimes in Verdent, sometimes just in a doc. The key is the instruction itself: do not help me feel right, help me find where I am wrong. That feels like the real prompt engineering for business work. submitted by /u/ApplicationNew4144 [link] [comments]

Help - AI agents for ecommerce - what’s actually working?

Hi everyone, I’d love to pick your brains and hear from anyone who has experience with this. We run an ecommerce business and are actively looking at automating repetitive tasks so we can get faster results, improve efficiency, and make sure key tasks are completed more consistently. We’re looking at building out a few different AI agents / automations, including: Customer Service Agent Connected to Outlook, reviewing incoming customer emails once a day and drafting replies for review. This one is already mostly done. Creative Director / Marketing Agent This would ideally: Review ad account performance Analyse creative performance and key metrics Identify what is working and what is not Review customer comments on ads, Instagram, etc. for wording, objections, pain points and customer language Review Meta Ads Library for competitor ad concepts Review Instagram and TikTok for high-performing niche content and trends Use all of the above to create new content ideas and final content scripts Social Media Assistant This would help with: Reviewing drafted posts and reels Confirming the best posting times based on stats Creating captions based on the content Keeping the content aligned with our brand voice and customer avatar Conversion Optimisation / CRO Expert This would assist with: Product page reviews Landing page recommendations CRO advice based on customer avatars, objections, analytics and learnings Creating landing page concepts for different customer segments We’re also interested in any dashboards that are genuinely helpful for small ecommerce businesses. We’ve already built a stock intelligence dashboard that pulls live stock data from Shopify using Supabase and a Cloudflare Worker. It shows current stock levels, production dates for new stock, and other key inventory insights. It has been super handy. The big thing for us is making sure any agents or automations we build follow strict guidelines, understand our SOPs, customer avatars, brand voice and business operations, and don’t hallucinate or produce generic outputs. Ideally, we want a system that has a proper “brain” and understands the business properly. Has anyone automated anything similar? I’d love to hear: What setup are you using? Which AI/tool stack has worked best for you? How did you structure the agents or workflows? How do you keep the AI aligned with your SOPs, brand voice and business rules? What would you avoid if you had to build it again? Any guidance, lessons or recommendations would be hugely appreciated. Thank you! submitted by /u/Majestic-Message5084 [link] [comments]

Synthetic DMS Training Data Generation with Video Models

I like spending my free time testing new AI tools and seeing where they might fit into real computer vision workflows. This time I experimented with synthetic training data generation for Driver Monitoring Systems using Seedance 2.0. The inspiration came from Vision Banana: https://vision-banana.github.io/ The idea that really caught my attention is simple but powerful: many vision tasks can be represented as RGB outputs. A segmentation mask, an instance mask, a depth map, or another dense prediction target can all be treated as an image-like output. So I tried to apply this thinking to video. The workflow: Generate a realistic synthetic driver monitoring video Use the same video to generate a semantic segmentation mask Use the same video to generate an instance segmentation mask Combine the outputs into a dataset-like structure The mosaic video shows the result: RGB video + semantic mask + instance mask, aligned frame by frame. The scene is a fictional driver gradually becoming drowsy behind the wheel. This kind of scenario is useful for DMS development, but difficult to collect and annotate at scale with real-world data. Of course, generated annotations still need QA. They are not perfect ground truth. But for prototyping, rare-case simulation, and early dataset generation, this feels like a very promising direction. The interesting part is that the final output is not just a nice synthetic video. It can become structured training data: RGB frames from the generated video semantic classes from the semantic mask object regions and bounding boxes from the instance mask YOLO / COCO-style annotations after post-processing I wrote a more detailed blog post about the experiment here: https://www.antal.ai/blog/synthetic_dms_training_data.html submitted by /u/Gloomy_Recognition_4 [link] [comments]

Building a Claude SEO Skill. Curious how people prefer SEO dashboards designed.

I recently started building a Claude SEO skill for myself that generates 3 kinds of SEO reports: GSC reports GA4 reports AI traffic performance reports Main reason was honestly, frustration. Every time I wanted to check performance properly, I had to keep switching between Search Console, GA4 and a bunch of dashboards just to connect what was happening. Right now, my workflow is: connect GSC + GA4 through Two Minute Reports → run the skill → get the reports generated automatically. I also created a separate GA4 segment specifically for AI referral traffic, so the skill pulls that into a separate report too. Still experimenting with it and trying to make the outputs genuinely useful. The main part I struggle with is the dashboard design. The output design feels slightly off and im looking for ways to refine it. Curious what kind of design/layouts people here actually prefer when checking SEO reports regularly. Is it like minimal summary dashboards, in-depth breakdowns, narrative-style or KPIs focused? submitted by /u/Holly_Bar_1295 [link] [comments]