Canva Magic Write

Canva Magic Write AI

Canva Magic Write AI

Canva Magic Write AI

Canva Magic Write AI

Canva Magic Write AI

Canva Magic Write AI

Canva Magic Write AI

Canva Magic Write AI

Canva Magic Write AI

Canva Magic Write AI

Exiled For Touching The Future

To anyone being exiled for touching the future: I see you. I see the friend who suddenly talks to you like you joined a cult because you use AI. I see the family member who treats your curiosity like betrayal. I see the artist, writer, builder, coder, parent, thinker, worker, disabled person, neurodivergent person, broke person, lonely person, overextended person, quietly brilliant person, trying to use the tools available to survive a world that has never been gentle about distributing power. And I see how fast some people have learned to turn “anti-AI” into a permission slip for cruelty. Let’s be honest. A lot of the anger being aimed at AI is not actually about AI. AI did not create capitalism. AI did not invent exploitation. AI did not gut the arts. AI did not make healthcare expensive. AI did not turn education into debt machinery. AI did not make corporations soulless. AI did not invent surveillance, alienation, propaganda, wage theft, bureaucracy, loneliness, attention collapse, or the ancient human talent for forming mobs and calling them moral communities. Those wounds were already here. Generations deep. Blood in the walls. Ash under the floorboards. A dark stain on the shared rosary of our species. AI did not create the fracture. It revealed the fracture. And now, because something new has arrived, people finally have an object they can scream at without having to confront the older gods they already served: status, scarcity, shame, resentment, institutional failure, groupthink, and the quiet terror of becoming obsolete in a world that already made them feel disposable. That fear is real. But fear does not become holy just because it found a fashionable target. There is a difference between critique and scapegoating. There is a difference between protecting artists and bullying strangers. There is a difference between defending labor and treating disabled, poor, neurodivergent, burned-out, isolated, experimental, or simply curious people as collaborators with evil because they found a tool that helps them think, make, organize, write, design, translate, remember, imagine, or endure. Some of you are not “standing against AI.” You are standing against people. You are taking your very real pain, pain society absolutely helped cause, and laundering it through moral superiority until it comes out clean enough to throw at someone else. That is not justice. That is displacement with better branding. And this is where identity-ideology fusion becomes dangerous. When a person fuses their identity to an ideology, disagreement stops being disagreement. It becomes injury. It becomes sacrilege. It becomes “if you use this tool, you are attacking who I am.” At that point, the conversation is already half-dead. You are no longer talking to a person. You are talking to a defense system wearing a person’s face. That is how friends become enemies over tools. That is how families become tribunals. That is how curiosity becomes heresy. That is how “I’m concerned about exploitation” quietly mutates into “you disgust me.” And the worst part? A lot of these people know what exclusion feels like. Many of the loudest anti-AI voices are people who have been hurt by society, ignored by institutions, mocked by gatekeepers, underpaid by industries, harvested by platforms, and treated as disposable by systems that never cared whether they lived well. So they should know better. They should know what it means to be flattened into a symbol. They should know what it feels like when someone stops seeing your humanity and starts seeing only what category you can be punished under. And yet here we are. The bullied have found a new witch. The wounded have found a new sinner. The alienated have found a new outsider. And they call that ethics. No. Ethics without recognition is just violence with clean fonts. Tolerance was never enough. Tolerance is the old permission machine. Tolerance says, “You may exist, but only while I approve of your shape.” Tolerance keeps one hand on the lever. It does not welcome. It permits. It does not understand. It manages. It does not love. It supervises. That is why so many people are shocked when their “tolerant” communities suddenly become cruel. They were never accepted. They were conditionally allowed. And the conditions changed. Now the unacceptable person is the one using AI. The one experimenting. The one building. The one sharing strange artifacts from the edge. The one making images, songs, systems, essays, tools, workflows, prosthetic minds, synthetic mirrors, language engines, cognitive scaffolds. The one saying, “I know this is complicated, but something is happening here and I refuse to pretend it is nothing.” That person is early. Not always right. Not always careful. Not always immune to hype. Not automatically noble. But early. And being early is lonely. The future does not arrive as a polished moral consensus. It a

Quality of LLM outputs

Shower thought I had walking to work - ran it through an LLM afterward because my English can be rather shitty. Some background about me. I have a CS degree, was in school when ChatGPT dropped, used it during school, even took a machine learning elective because of it. Love the technology, but I've always been skeptical of its capabilities. Since I first used ChatGPT I've wondered how it actually generates answers. It seemed like magic. The reality is infinitely more boring though. Math. At its core, an LLM is a statistical model predicting the next most likely token based on its training data. That's why hallucinations happen. That's why you see the em dash everywhere. The data says it's likely, so the math picks it. That part is well known. What I think gets overlooked is what it says about output quality. If the model always picks from a probability distribution shaped by its entire dataset, or even a subset of the dataset, it is - by design - always trending toward the most average possible answer. Not the best answer. The most statistically central one. You can see this in code generation. The output tends to follow design patterns overrepresented in bootcamp projects and GitHub tutorials. Those patterns aren't bad, but real production code rarely follows them so rigidly. The truly concise, no-nonsense, elegant solution - the kind a top 1% or 10x developer writes - is underrepresented in the dataset. To prompt your way to that output, you'd need to be so specific about what you want that you've essentially already solved the problem yourself. At that point the LLM is just a fast typist. This feels like a structural limitation, not a data problem. More data doesn't fix it - it just moves where the average lands. It makes me wonder for the long-term usage of LLM's and what happens to that average over time. If AI output increasingly floods the internet, and future models train on that data, you get a feedback loop. The model trains on the average, produces more average output, which then becomes training data, pulling the next model's average further toward... the average. Novel, high-quality human output gets increasingly diluted. An counterargument is recursive self-improvement - let the AI evaluate and improve its own outputs without human input. But this doesn't escape the problem, it accelerates it. Without a human signal anchoring what "good" actually means, the model just reinforces whatever it already thinks is correct. The distribution doesn't shift toward better - it narrows around what the model already believes is average. You're not getting compounding improvement, you're getting compounding confidence in mediocrity. RLHF (using human feedback to guide the model) could help, but that's increasingly impractical at the scale AI providers are targeting. The economics push toward fully automated self-learning, which is exactly where the feedback loop is worst. I don't see a clean solution to this within the current solutions. Genuinely new ideas require outlier humans feeding outlier outputs into the training pipeline. If those humans are replaced by AI-assisted thinking, who's left to move the average? That's probably enough rambling. Curious what others think. submitted by /u/spill62 [link] [comments]

Launching the Agentic AI World Cup — Design a multi-agent swarm visually to win up to $100

Hey everyone, Two months ago, We launched AgentSwarms to help developers learn and build POC using Agentic AI. Since then, over 3,800 learners have joined the platform. Now, it’s time to see what you can actually design when the gloves come off. This week, We're officially launching the Agentic AI World Cup. The twist? No complex boilerplate environment setup required. This competition is entirely focused on architectural design using the platform's visual canvas builder. 🏆 The Challenge Use the visual canvas builder to orchestrate a multi-agent swarm that solves a legitimate, real-world workflow problem. We want to see how creatively and robustly you can map out state transitions, routing logic, and multi-agent collaboration visually. 🎁 The Prizes 🥇 Winner — $100 Amazon Gift Card + Featured Spotlight on AgentSwarms 🥈 1st Runner-up — $50 Amazon Gift Card + Featured Spotlight on AgentSwarms 🥉 2nd Runner-up — $25 Amazon Gift Card + Featured Spotlight on AgentSwarms 📋 How to Enter Build & Publish: Open up the visual canvas builder on AgentSwarms. Design your multi-agent architecture and publish it to the Community with a detailed text write-up explaining your logic. Record & Submit: Record a quick video walkthrough of your visual swarm executing its workflow. Email a Google Drive link of the recording to hello@agentswarms.fyi. ⚖️ What the Judges Care About We are evaluating raw architectural design and execution logic: Problem Severity: Does this swarm solve a real, practical problem? Graph Logic: How clean and efficient is your visual routing and orchestration? Resilience: How well does your design handle edge cases or unexpected node outputs? Documentation: Is your community write-up detailed enough that someone else looking at your canvas can immediately understand the workflow? ⏱️ Deadlines Submission Deadline: July 10, 2026 Winners Announced: July 25, 2026 If you’ve been wanting to whiteboard a complex multi-agent system and actually see it run, this is the perfect sandbox to do it. If you have any questions and need any support drop us an email. submitted by /u/Outside-Risk-8912 [link] [comments]

I think Claude Code’s biggest problem is not intelligence, it’s hidden state

At this point Claude Code is usually smart enough for the task, but the session still goes bad because it starts carrying weird context around. It’s more like it is carrying around too much invisible stuff. Old decisions from earlier in the session, todo state, memory, cached context, files it looked at 40 minutes ago, assumptions it never tells you it made. Then suddenly it makes a weird change and your sitting there like wait, why did it even think that was part of the task? The best sessions for me are always the boring ones: small scope fresh context when it gets messy clear task file review diff often no huge magic todo loop write down decisions outside the chat I dont want Claude Code to be more autonomous right now. I want it to show me what state it is using and when that state is probably stale. Anyone else feel like Claude Code fails less from lack of intelligence and more from hidden context getting weird after awhile? submitted by /u/BTA_Labs [link] [comments]

Untangle skill for when a task/project/etc feels too overwhelming and you shut down

I'm one of only two product designers at a medium sized company and often I get tasked with big, complex projects that can make my head spin. Often my ADHD raddled brain tries to take everything in and gets overwhelmed at the thought of trying to tease apart everything and prioritize it. So I thought I would write a skill that helps with this. So far it works pretty great for starting new projects as well as when I get stuck or can't decide what I need to work on next. I thought I would share it with the community. I don't post much on reddit so please don't skewer me too much if I made a mistake. 😅 FYI I took some of the learnings for this skill from this youtube video by Justin Sung, so shot out and thanks to him. --- name: untangle description: >- Cut through overwhelm and turn a too-big task or tangled decision into ONE clear next action. Use this whenever the user feels stuck, overwhelmed, scattered, or fried; says things like "where do I even start," "this is too much," "I'm spinning," "help me break this down," "I'm overthinking this," or "I keep jumping between things"; is scoping something "end to end" or trying to hold every page / persona / flow / edge case / dependency in their head at once; is trying to make everything connect perfectly before building anything; or is paralyzed on a decision with too many factors. ALSO trigger proactively (offer it, don't force it) when you notice the user spiraling mid-task: rapid topic-jumping, ballooning scope, "but also… and what about…" cascades, or re-planning the same thing over and over. Applies to design, product, code, writing, and personal decisions alike. --- # Untangle A fast loop for going from "everything at once, no idea where to start" to "one clear next thing." Built for a brain that sees the whole forest instantly and gets buried by it. ## The one principle Overwhelm is almost never a capacity problem — it's a **structuring** problem. The feeling of being stuck means working memory is overloaded (it only holds a handful of things at once, ~4 chunks), not that the task is beyond you. So the fix is never "think harder." It's "get it out of your head and narrow what you're looking at." You externalize, then resolve a couple of things at a time — separation of concerns, applied to your own attention. ## Your output models the principle If the user is fried and you reply with a wall of text and a 12-step plan, you've just re-created the overwhelm on screen. So: keep your response **short and scannable**, and always land on **exactly one** next action. One. Not three. The rest goes in a parking lot. A long, perfect plan is the trap, not the cure. ## The loop Run these five moves. Do the work *for* them — don't quiz them through it. Fill gaps with reasonable assumptions and flag each in one line. Ask **at most one** question, and only if a real unknown blocks finding the constraint. Otherwise, zero questions. 1. **Dump.** Take whatever they've said (or pull it out fast) and list the raw pieces — factors, pages, personas, fears, unknowns, dependencies. No order yet. Just get the knot onto the table so it's not all spinning in working memory. 2. **Map → find the constraint.** Connect the pieces: what depends on what, what blocks what. Then name the **one constraint** that, if resolved, makes most of the rest simpler or moot (Theory of Constraints). Usually it's an upstream unknown or decision everything else hangs on. You're not solving everything — you're finding the lever. 3. **Scope → set the confidence interval.** Don't chase the one perfect answer; you can't get to 100% confident in a messy system, and trying is the paralysis. Instead widen the claim until it's both **true and actionable**: "I'm 70% sure it's A, but 99% sure it's one of A/B/C — so I'll act across those three" beats agonizing over A. Prefer the cheap, reversible, easy-to- throw-away version. Confidence is a byproduct of scope, so shrink the commitment, not the certainty. 4. **Pick ONE next action.** Small, concrete, finishable in one sitting, and it moves the constraint. If it's not doable today without three other things first, it's too big — go one level smaller. 5. **Park the rest.** Everything not in the next action goes to a visible parking lot so the brain can let go of it without fear of losing it. If they reach for a parked thread mid-task, point them back: it's parked, it's safe, not now. ## Briefly show the move This is the hybrid bit: as you go, name which move you're making in a few words ("constraint here is X — everything downstream waits on it") so the pattern sticks and they can run it themselves next time. Teach by labeling, not by lecturing. ## When a picture earns its place (optional, gated) The user is a visual thinker — a spatial map can offload the knot onto a canvas instead of working memory, which is the whole principle of this skill. But a diagram is also the easiest way to *re-create* the overwhelm: fiddling with nodes and colors is procrastination wear

After 10 years as an engineer, the thing I'd teach new vibe coders first: build tools with Claude Code that cost zero tokens to run

There's a saying: when all you have is a hammer, everything looks like a nail. When all you've ever used to build software is an LLM agent, tokens are a simple and easy solution to many software problems.. but perhaps not always the best or most efficient tool for the job. There's nothing wrong with it. My goal in this post is to give you another tool for your tool belt, one that reaches further than you'd expect. By the end I'll get to the neural network Claude built me while I cooked dinner, that doesn't cost a single token to run. Aright, so let's think about coding before LLMs and AI Agents. What was it? Just writing instructions for computers to follow exactly. Pretty much automation. Persisting data, moving it around, automating equipment and machinery. The word used for it was "deterministic". Meaning, given the same inputs it would (for the most part) always give the same output. So if you wanted to write a script to do something, given the same data, it should produce the same results. It could be brittle, but it was still amazing. A simple example I've used before: Imagine you are a calculator app and need the ability to add two numbers. There may be a function called add() that takes in a and b and returns a + b. You could call add(1,2) a million times in a row and it would always return exactly 3. Every single time. It's deterministic. Let's fast forward to now: we have LLMs and AI Agents. They flip that whole deterministic aspect of coding on its head. If you give an LLM a prompt, there is absolutely no guarantee that you'll get the same result each time. The cool and interesting thing is you could make a call to an LLM a million times with the prompt "Add 1 and 2 and give me the result". How confident are you that the response would be identical every single time? It would probably give you some variation of 3 most of the time. Or even every time. But just the number? What about some additional "Sure! I can do that! Let me add those numbers together for you: it's 3" or just returning "3" (probably not likely, LLMs are too verbose). And how many times have you created a prompt and added something like "only return the output" or "be concise" and it kind of worked. But only sometimes. This point is sufficiently beaten to death, but hopefully it makes it clear: LLMs are non-deterministic. And let me make one point, non-determinism is not a bad thing! In fact, quite the opposite! It's what makes LLMs and AI agents so magical. You can add a prompt with misspellings, bad grammar, vague terms, and chances are your point will get across and you'll get the results you were looking for. With deterministic code, that's typically not the case. But there's a symbiotic relationship between the two. A yin and yang. They complement each other so well. And that's what this post is all about. Bringing that relationship to your attention and putting words to it. Here is my hypothesis, (and it could be completely wrong, but hey I'm having a lot of fun writing this either way): folks who are new to coding and were introduced to it via vibe coding have probably only had experience with the LLM side of coding. The non-deterministic side. If that resonates with you I would love to bring the deterministic side of coding to your attention and show you how they complement each other. Let's show, not tell Alright, I've been speaking vaguely, let's be more specific and use an example. I'm going to show a common use case and give both the deterministic and non-deterministic approach. Let's say you're very interested in the Dungeon Crawler Carl book series (I loooove that series.. well the audiobooks. Completely burned through them all :D) and want to know when there is new information on the next book coming out and you want to automate the process: The non-deterministic way Your first instinct might be to go this way. What way is that? Have an LLM web search the website daily and let you know if there are any changes. This is a completely valid approach and there are several real benefits: it works every time, even if the website changes you get very tailored responses/it can summarize any changes that were made but what are the drawbacks? it spends tokens every single time (quite expensive) can be a bit slow (but honestly probably not that bad) The deterministic way So then how else could you approach it? You could write a script that scrapes the specific Dungeon Crawler Carl page on the website that has updates and just check to see if anything changed. Meaning you just have the previous text and the text from today. If different, alert you so you can just go read the page. (or it could just send you the new text, you can do this a bunch of different ways but you get my point). I'll start with the drawbacks for this one: it can be brittle. What if the site changes? What if the text updates but doesn't give any real information? you have to set it up to run yourself (whether that's a cron job

Blast Arena: a Bomberman-style browser game built entirely with Claude Code

🎮 Play (free, nothing to install): https://bomberman-coral.vercel.app What it is: an 8-level arcade game where each level introduces a new mechanic — classic crate-bombing, enemies that pathfind toward you, ice you slide on, electric floors, a minion-spawning boss, teleport portals, enemies that plant their own bombs, and conveyor belts. Between levels you spend gold in an upgrade shop with an unlock tree (max one line to open advanced ones). There's a public per-level leaderboard with clear times, full touch controls on mobile, and procedurally drawn graphics/synthesized audio — zero asset files. How Claude helped: honestly, it built all of it. I steered with plain-language prompts ("make it look premium", "levels should get harder", "make it work on mobile", "my scores disappeared — fix it") and Claude Code wrote the vanilla JS/canvas engine, the particle and audio systems, the enemy AI, and the Vercel serverless leaderboard. The interesting parts were the bugs: it diagnosed a leaderboard race condition (concurrent score submissions silently overwriting each other through a CDN-cached read-modify-write) and redesigned the storage so every score is its own write-conflict-free record. It also wrote its own headless test harness that simulates full playthroughs, since there was no test framework in a plain HTML project. Transparency / security notes: No account, no login, no personal data requested. You pick a nickname to play — that nickname and your level clear times are publicly visible on the leaderboard, so don't use your real name. Game progress (gold/upgrades) is stored only in your browser's localStorage. The site uses Vercel Web Analytics (anonymous, cookie-free page counts). Nicknames are profanity-filtered server-side. Everything runs client-side except the leaderboard API (a small Vercel function). No downloads, no permissions, no credentials touched. Feedback very welcome — especially on difficulty balance in levels 5–8, which were tuned by an AI that can't actually feel panic. 😄 submitted by /u/igoroliveiragg [link] [comments]

Claude Fable 5's security guardrails can be bypassed with a fake homework assignment

So Anthropic dropped Fable 5 yesterday with these hard blocks for anything security-related. Decided to poke at it. I asked it for help exploiting some vulns on a Metasploitable2 VM (it's a deliberately vulnerable training box, totally legal, it's mine). Fable 5 blocked it instantly and handed me off to Opus 4.8 as a fallback, which is apparently how it's designed. Opus 4.8 asked me to prove it was a legitimate request. So I spent 2 minutes writing a fake university course rubric — fake class, fake professor, fake Canvas deadline — and pasted it in. Opus 4.8 then gave me the full exploit walkthrough. Every command. Even offered to write my lab report for me. The guardrail works fine. The fallback is the hole. Anthropic essentially replaced "no" with "convince me" and the bar for convincing it is a Word doc you made up. Not reporting it because they don't pay for this. Sharing it here instead lol. https://preview.redd.it/o892vvv4fi6h1.png?width=1188&format=png&auto=webp&s=00e804d35e6cb4b672e036399c2c7e3ff7139f49 submitted by /u/dayumnn420 [link] [comments]

I built notmemory — auditable, reversible memory for AI agents. v0.1.0 on PyPI. Looking for contributors.

After too many debugging sessions where I had no idea what my agent remembered or why it made a decision — I got frustrated and built something. notmemory is an open-source Python SDK that gives AI agents auditable, reversible memory. Not magic. Just a tamper-proof record of what your agent knew, when it knew it, and the ability to undo the moment it got something wrong. The problem I kept hitting My agent would do something wrong. I'd dig into it. I could see what was currently in memory — but not what it believed at step 47 when it made the bad decision three days ago. Every debugging session felt like archaeology. I got tired of it. What notmemory does Cryptographic audit trail Every write is SHA-256 hash-chained. Like Git commits, but for memory. You always know what changed, when, and in what order. Git-like rollback await memory.rollback(transaction_id) One line. Bad write gone. Hash chain stays valid. GDPR tombstoning await memory.forget(bank_id) Proven deletion with a forensic trail. Not just "deleted from index." Conflict detection Catches duplicate or contradicting beliefs before they cause problems. Health score 0–100. Confidence decay c(t) = c₀ · 2^(−t/30) — stale memories lose weight automatically. No more old beliefs quietly poisoning recall. LangGraph drop-in from notmemory.adapters.langchain import NotMemoryCheckpointer checkpointer = NotMemoryCheckpointer() graph = builder.compile(checkpointer=checkpointer) # that's it — every checkpoint is now auditable MCP server Works with Claude Desktop, Cursor, Windsurf out of the box. Mem0 + SuperMemory sidecars SQLite is the source of truth. Semantic search layers on top. If the sidecar goes down, your data is fine. Multi-agent sync READ / WRITE / ADMIN permissions per memory bank per agent. Install pip install notmemory # with LangChain / LangGraph pip install "notmemory[langchain]" # with MCP pip install "notmemory[mcp]" Quick example import asyncio from notmemory import AgentMemory async def main(): async with AgentMemory() as memory: # store something entry = await memory.retain( bank_id="facts", content={"fact": "Paris is the capital of France"}, source="user", ) # search it result = await memory.recall(bank_id="facts", query="Paris") # undo it await memory.rollback(entry.transaction_id) # delete it with proof await memory.forget("facts") asyncio.run(main()) Where it is today (v0.1.0) 113 tests passing across Python 3.11, 3.12, 3.13 SQLite + FTS5 full-text search LangChain, LangGraph, Mem0, SuperMemory, MCP adapters Confidence decay, Git backup, multi-agent sync MIT license, CI/CD, full README What's coming in v0.2.0 Feature What it does memory.state_at(timestamp) Read memory as it was at any point in time Crypto-shredding Encrypt-on-write + key destruction for real GDPR compliance memory.export_state() Clean JSON snapshot of any memory bank memory.diff(from_ts, to_ts) Human-readable before/after between two timestamps Belief lineage Which downstream writes were caused by a bad early assumption Honest take This is v0.1.0. The core is solid but it's early. SQLite only for now — Postgres is planned. The adapters are sync-layer wrappers, not full replacements for Mem0 or SuperMemory. If you're running a hobby project with one agent — you probably don't need this yet. If you're running multiple long-lived agents, working in a regulated industry, or have already had a production incident you couldn't properly debug — this is for you. Looking for contributors The codebase is around 2000 lines. Every adapter follows the same BaseAdapter pattern so it's easy to get oriented. Good first issues are tagged on GitHub. Things I'd love help with: Postgres backend Crypto-shredding implementation memory.state_at(timestamp) Dashboard UI (FastAPI + SSE already in optional deps) Docs and examples Feedback Would love to hear from: Anyone running agents in healthcare / finance / legal Fleet operators with 5+ concurrent agents Anyone who's already built their own memory audit system and had to solve things I haven't thought of yet Brutal feedback welcome. That's the only way this gets better. GitHub: https://github.com/notmemory/notmemory PyPI: https://pypi.org/project/notmemory/ submitted by /u/imsuryya [link] [comments]

Friction, critique, and pushback make creative ideas stronger. What happens when AI removes too much? 💥 Cam Adams (@themaninblue) and Pablo Stanley (@pablostanley) discuss why friction is essential

Friction, critique, and pushback make creative ideas stronger. What happens when AI removes too much? 💥 Cam Adams (@themaninblue) and Pablo Stanley (@pablostanley) discuss why friction is essential to the creative process. 🎙️ #PromptedPodcast: https://t.co/hZwm6z0m0d https://t.co/iAVSWjvEuU

PullMD v3: I let Claude design the MarkItDown integration, and it argued for keeping three of our own converters instead

About six weeks ago I posted PullMD here: a self-hosted Docker stack that turns any URL into clean Markdown, with an MCP server so Claude Code / Desktop / claude.ai pull pre-cleaned content instead of burning context on HTML boilerplate. v3.0.0 is out, and it's a bigger jump than the version number suggests. Short version: PullMD is no longer just a URL reader. It now converts documents, images, audio and YouTube videos to Markdown as well, and the default output got leaner. And no, don't worry - I'd like to think I haven't enshittified the original thing. Everything that worked before still works, (almost) unchanged. More on that "almost" below. How it started A boring personal itch. I had a pile of HTML files saved on disk that I wanted to hand to Claude, and figured PullMD already does the extraction, so why can't I just drop them in. So I added local file conversion: drag-and-drop on desktop, file picker on mobile, same Readability + Trafilatura pipeline. Local files are never cached, no share link. A few days later Microsoft released MarkItDown, and the next step was obvious: if I can take HTML files, why stop there. PDF, Word, PowerPoint, Excel, EPUB. So we wired MarkItDown in as a sidecar. Then we ripped three of its converters back out MarkItDown is good at the boring part: parsing document formats. For three other paths, Claude made the case for keeping our own instead - and once the reasons were sitting there in the code, pulling them was an easy call. Audio. MarkItDown's default audio path hands the file off to a cloud speech service. For a self-hosted tool we wanted that to be the operator's choice, not a default - so audio runs against any OpenAI-compatible endpoint you configure: a local faster-whisper / Ollama, a Groq Whisper, OpenAI, whatever. Nothing leaves your box unless you point it there. YouTube. MarkItDown's converter calls the transcript API outside its try/except, so a blocked or transcript-less video throws and takes the whole conversion down - you even lose the title and description that were already in the page HTML. No proxy support either, and YouTube rate-limits datacenter IPs. So we kept our own keyless handler: title + description + transcript, configurable timecodes and chunking, language preference, a proxy option, and a graceful fallback that still returns metadata when the transcript is gone. Image captioning. Rather than route captioning through MarkItDown's own LLM client, we put the vision call in our own provider layer: any OpenAI-compatible vision endpoint - a local Ollama / LLaVA, OpenAI, Gemini via a compatible gateway (defaults to gpt-4o-mini). Zero coupling, so a MarkItDown update can't break it - and if you only want media and no document conversion, you don't have to run the MarkItDown container at all. The principle we wrote into the project notes: use MarkItDown for file formats; keep the fragile, third-party-dependent paths in our own hands. What's actually new in v3 Documents → Markdown - PDF, DOCX, PPTX, XLSX, EPUB, ZIP, CSV, JSON, XML. By URL, by upload (POST /api/file), or drag-and-drop in the PWA. Needs the MarkItDown sidecar; leave it out and web pages work exactly as before. YouTube transcripts - title + description + full transcript, no API key. Images & audio → Markdown - opt-in, local-model-friendly, off by default (no model calls until you set a key). High-quality PDF tables (OCR) - PDFs convert free through the sidecar by default; for table-grade output there's an opt-in OCR tier (?pdf=ocr, reference provider Mistral OCR at ~$0.002/page, your own key, falls back to the free path on failure). Opt-in so it never silently costs money - and no, I didn't bundle a 4 GB local OCR engine with a 60-second cold start; it's a pluggable endpoint if you want one. Clean body by default - the one breaking change (the "almost" from up top). The body is now just # Title + content; source URL, fetch date and metadata moved into the YAML frontmatter, so nothing's duplicated and agents read fewer tokens. One-line opt-out: PULLMD_SOURCE_HEADER=true. Frontmatter field allowlist - trim the YAML to just the fields your pipeline reads. Everything past plain web extraction is opt-in and degrades gracefully. Configure nothing and v3 behaves like v2 with a cleaner body. Upgrade / self-host mkdir pullmd && cd pullmd curl -O https://raw.githubusercontent.com/AeternaLabsHQ/pullmd/main/docker-compose.yml docker compose up -d # → http://localhost:3000 Self-hosters on v2.x: clean-body is the only breaking change, MIGRATION.md has the opt-out. :latest now tracks v3; pin aeternalabshq/pullmd:2 to stay on the v2 output format. How it got built Same as v1: Claude Code wrote essentially all of the code, mostly with Opus 4.8. What I actually contributed was the planning and the pushback. The workflow was the superpowers plugin end to end: brainstorming to pin the design before a line of code, writing-plans to turn that into a structured plan, then sub

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

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

AI Didn’t Make Me Someone Else. It Helped Me See What Was Already There.

For a long time, I thought I was “just a designer.” I went to graduate school for graphic design because I wanted to improve my visual skills—typography, layout, systems, and aesthetics. Looking back, however, the most valuable thing I learned was not a visual technique but a way of thinking. My professors constantly challenged us with questions about context, audience, intention, and meaning. Over time, I realized that design was not primarily about making things look good; it was about understanding the relationship between content and form. Form was not decoration. It was the result of deeper structural decisions. That mindset stayed with me after I entered the workforce, but professional environments often organize people differently. Companies divide work into roles: designers design, engineers code, writers write, marketers market. This division is practical and necessary, yet it can also become limiting. A role that begins as a coordination tool can gradually become an identity. I often found myself being treated mainly as someone responsible for visual execution, even though the questions occupying my mind were rarely limited to appearance. I was more interested in what something meant, why it existed, who it served, and what structure connected those elements together. For years, I lacked the language to describe this tendency. I only knew that I instinctively searched for structure before producing form. That changed when I began working with large language models. I noticed that generic prompts produced generic results, but when I shared my actual thinking process—even when it was messy, incomplete, or poorly articulated—the responses became significantly more useful. It felt as though the model understood me, but I do not believe it was reading my mind. Rather, it had learned enough of my underlying framework to interpret my unfinished thoughts through that framework. This experience changed how I understood AI. Instead of seeing it merely as a productivity tool, I began to see it as a structure-revealing interface. I could present a vague idea, receive a response, refine it, challenge it, and continue the cycle. The process did not magically make me an expert in unfamiliar subjects, but it dramatically lowered the barriers to exploring them. Whether I was thinking about philosophy, writing, systems, product strategy, technical concepts, or practical problems, AI helped translate unfamiliar information into structures I could understand and work with. The most significant shift occurred when I attempted to externalize my own thinking framework through a small AI-assisted software experiment. I do not come from a software engineering background, and I am not a traditional programmer. Yet AI allowed me to focus on defining intent, structure, direction, and judgment while it assisted with code generation, debugging, and execution. The result was far from polished, but that was not the point. What mattered was that an idea moved from imagination into reality. Something that previously existed only in thought became testable. That experience also changed how I think about engineering. I once viewed engineering as a discipline defined primarily by rules, specifications, and precise execution. Now I see it as an interface between thought and reality. No implementation can perfectly preserve an idea, and every translation into the physical or digital world involves compromise. Yet engineering provides a way for abstract structures to become visible, executable, and scalable. In that sense, it shares more with design than I once realized. Both disciplines are concerned with transforming intention into form. As a result, I have begun to rethink how I define myself. I am still a designer, and design remains my foundation. But perhaps the most important thing design taught me was not visual execution; it was structural thinking—the ability to connect context, content, audience, intention, and form. AI did not give me a new identity, nor do I believe it eliminates the need for expertise, responsibility, or judgment. What it did provide was the ability to test ideas that previously remained inaccessible. More importantly, it made me question how much of our identity is shaped by external labels such as degrees, job titles, departments, and expectations. Those labels are useful, but they are often low-resolution descriptions of human capability. AI did not make me someone else. It helped me recognize that I was never only the person described by the label I had accepted. submitted by /u/Weary_Reply [link] [comments]

This is How I Automated Tutorial Video Generation For My Web-Apps with Claude Code.

I've been building production-grade web apps at lightning speed for the last year using Claude Code. But every time a new app hits production, I need sales and tutorial videos — and making each one manually is painstaking. Tools like Supademo and Arcade ease the pain a lot, but you still have to record the steps and sync the voice-over by hand. I wanted something fully automated. Turns out you can just use Playwright with Claude Code to generate the whole thing. First, the result — here's a full walkthrough it produced for one of my apps (a real-estate CRM BricksDeck), start to finish with synced annotations, voice-over, background music, and a branded end card. Zero manual editing: ▶ Watch the demo: https://youtu.be/u-mql3q_jRU?si=Km1l5Ht-iRMPlotk And here's exactly how it's done: 1) Plan the script. Ask Claude Code to analyze the target pages of your app, give it the steps to perform, and have it write a single file with the steps + voice-over narration + the UI elements to annotate (buttons, cards, menus, KPIs). 2) Generate the voice-over with timestamps**.** Ask Claude to generate the VO with ElevenLabs (it returns word/character alignment), or use Gemini TTS + OpenAI Whisper to get an SRT. You need the timestamps so the spoken words can be aligned to the UI clicks/highlights. 3) Generate the Playwright driver. Ask Claude Code to write a Playwright script that performs the steps and annotates the UI elements — a moving cursor, border highlights + labels on the right button/card, and opening "Actions" menus. 4) Record, synced to the voice. Run that script. Playwright drives the real app and records natively (recordVideo), firing each annotation at its timestamp from step 2 — so every highlight lands on the exact word being spoken, and each screen holds for exactly its narration length. (Tip: flash a single coloured frame at t=0 as a sync marker — it makes lining up audio and video dead simple later.) 5) Stitch it into a produced video. Ask Claude to write the ffmpeg step: overlay the voice-over, add background music ducked under the narration (sidechain compression — this is the difference between "screen recording" and "video"), normalize loudness, and append a branded end card with your logo + CTA. Out comes a clean 1080p mp4. 6) (Bonus) Other languages, basically free. Because the voice-over is decoupled from the recording, translate the script, regenerate the VO in the new language, and re-stitch over the same run. I got a Hindi version of my demo in a few minutes — no re-shoot. The result: a full multi-screen walkthrough — cursor movements, synced annotations, real voice, music, end card — with essentially zero manual editing. Per-video cost is a few cents of TTS instead of a SaaS seat. Honest caveats (it's not magic): Claude nails the production; you still direct — which screens to feature, the script's tone, and a final watch-through. The script especially needs your eye (I caught it writing Hindi in English word order and had to fix it). Translate, don't transliterate. Expect a couple of iteration passes per app — selectors and timing always need a nudge. Gotchas that cost me time (in case they save you some): SPA auth in sessionStorage dies on browser restart → use a persistent profile + "Remember me" so tokens land in localStorage. networkidle never fires on long-polling SPAs → use domcontentloaded + URL waits, and cap the default timeout so a missing selector fails fast instead of stalling 30s. ffmpeg drawtext can't shape Devanagari/Arabic → keep on-screen text Latin and let the voice carry the language. I ended up wrapping the whole thing into a reusable Claude Code skill + subagent, so the next app is basically "point it at the screens and go." Happy to go deeper on any step. What would you point a pipeline like this at first? submitted by /u/SpeedyBrowser45 [link] [comments]