Arc Search

Arc Search AI

Arc Search AI

Arc Search AI

Arc Search AI

Arc Search AI

Arc Search AI

Arc Search AI

Arc Search AI

Arc Search AI

Arc Search AI

Building a Pokémon ROM hack demo with an AI coding assistant: a process report

Disclaimer: The text below was written mostly by Claude. I edited it, but it is not my original work. This is a report on building a playable ROM hack demo using Claude (via Claude Code in a terminal) as the primary coding assistant. The goal is to describe the process for someone in a specific position: familiar with ROM hacks as a player and comfortable with general software development, but with no prior knowledge of how ROM hacks are actually built. Result, for context: a region called Coalveil with 30 custom maps, 2 gyms, an opening story arc, custom tilesets and trainer sprites, and a credits roll. Playable start to finish. Built over roughly two weeks of evenings. To be clear about the art: the custom tilesets and sprites were imported and adapted from existing fan-made assets — none of it was AI-generated. Motivation The point of the project was to prove to myself that building a full ROM hack is actually feasible. Rather than start open-ended, I set a deliberately specific scope — a vertical slice of two gyms and the story up to a defined endpoint — and worked straight through it. Keeping the scope fixed was what made it finishable. The goals were both technical and creative, and the project served both at once: Technical: figure out how the various pieces of a hack are actually done — maps, scripting, tilesets, sprites, gating. Creative: tell a particular kind of story I had in mind, in the form of a region and its characters, rather than build a generic test bed. It should feel like a demo for an actual game, not just a tech demo. Starting point Relevant background: ROM hacks: played many; no development experience with them. Software: comfortable with software engineering, zero experience in C. ROM hacking internals: none. I did not know how a hack is structured. The first thing to learn was the basic model. Modern Pokémon ROM hacking builds on a decompilation — pret/pokeemerald, or in this case rh-hideout/pokeemerald-expansion — which is the full game as readable C and data files that compile back into a ROM. For someone with a development background, this reframes the task as a C project with an unfamiliar domain. In practice there was very little actual C coding involved — just some small changes like making the fog denser. The bulk of the work was scripting and mapping. Workflow The process settled into a consistent loop over the first few days. Design before code. I had the assistant maintain a set of design documents: a game bible, per-location docs, a story outline, and a gym/badge progression plan. The rule was that design lands in the docs before any code is written. This kept the project coherent as it grew. At least that was the plan — in practice I was too lazy to actually follow the rule. If I expand on the project, that rule should actually be enforced. Maps in Porymap, data wired by the assistant. Porymap is the map editor — a GUI for painting tiles and placing NPCs. The reliable pattern is to create each map in Porymap first, let it write the JSON and header files, then have the assistant fill in events, scripts, warps, and connections. Map creation and fine-tuning was the single biggest time consumer. Seemingly simple things — making the rival walk around the player rather than straight through them, getting a scene to feel right — take a long time to get correct. The assistant writes the scripting. Map scripting uses a macro language with flags, variables, trainer-battle modes, movement tables, and NPC-swap-on-flag patterns. I described scenes in plain English and got consistent, working scripts back. I still did a pass over most scripts to bring the tone in line with what I wanted — the assistant tends toward an "AI" voice and overdramatizes. By the end I could write my own scripts, but the assistant still made the work much more comfortable: filling a whole town from a single prompt and then polishing it is very fast. Verify, compile, playtest, correct. I played through the game a lot (see Limitations). Tooling pokeemerald-expansion — the decomp base; modern quality-of-life features and a wide species range. Porymap — map and tileset editor. porytiles — converts raw tileset art into the indexed/palette format the GBA requires; needed for importing community tilesets. gbagfx — graphics conversion tool that ships with the decomp. A handful of small convenience scripts for recurring tasks such as dialogue formatting. For consistency, I recorded the project conventions in an instruction file plus a few reusable task templates (add a map, add a trainer, fill a house), so the assistant could follow established patterns instead of being re-told them each time. This worked only partially — the rules failed to stick regularly, and reliably getting development conventions into the assistant's context is something I still need to improve. Issues encountered GBA graphics behaviour. The GBA's graphics format is old and impractical, and work

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

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

I helped Claude actually understand my Unity project

Hello fellow Claude enjoyers, I brought to you an interesting story about working with Claude in an extremely complex environment such as Unity. A bit of intro for those who don't know what Unity is. It's a cross-platform engine that's mostly used to develop indie games and mobile projects. Unity treats its project files as a web of interconnected elements. Imagine you have a Reddit app in front of you. Let's call your feed tab a scene. A scene is just a container to hold all items together; items are GameObjects that have dozens of components (scripts) which have multiple properties to edit. So all relations between these elements are complicated and convoluted, and Claude usually has a hard time navigating it. And the reason is simple: links and relations often go one way, so item A knows that it uses item B, but doesn't know that it's being used by item C. So with high probability Claude will find item B but might miss item C. And that's just a basic example, but in the Unity world — you can usually multiply this example by 10, or by 20 different elements relating to assets, cross-references, and so on. And the thing is — Unity knows exactly all of that, but it's barely readable from its files. That's how I came up with Hades. It's a Unity dependency graph, living inside Unity itself as a plugin. And it's exposed to Claude via MCP tools spiced with Skills and guidelines. And while working on it I got annoyed with one thing during my job — I have to remind Claude of some crucial details between sessions about my project, because of its complexity it's hard to just grep it from reading code. So, additionally I decided to build a layer I called Asphodel — persistent project memory, also reachable via MCP tools for your agent. Its main idea: you can't put 100% of must-have info in your CLAUDE.md, but you can build a bank storing it, and let the agent query it on occasion! (Queries are cool! Aren't they? xD) So you ask Claude, let's say, "I want to build a new enemy with a different behaviour pattern" — and instead of a raw search on files, Claude queries the Hades Graph and Asphodel by keywords. The Graph will return the same scripts that a search does, but including all references to inner Unity assets like Scenes, Prefabs, ScriptableObjects, etc. And Asphodel will return guidelines that you built in that match the topic — "All future enemy behaviour must be a prefab variant of the EnemyBase prefab, but they don't have to inherit any C# code", for example. If you are interested in field tests: I run the same prompt on the same project with and without Hades: "I want to change how EnemyAI works on enemies. Which prefabs and scenes are affected?" — on a small arena with a base Enemy prefab + 3 variants that inherit EnemyAI, used across 3 scenes. The correct answer is 4 prefabs across 3 scenes. Without Hades: it found 1 prefab and 1 scene — then confidently suggested "add EnemyAI to the variants," which would actually break the prefab inheritance. Wrong and misleading With Hades: 4 prefabs, 3 scenes, correct — and as a bonus it pulled ~43% less context and cost ~27% less, because it queried the graph instead of grepping around. Same model, same project, the only variable is Hades on/off. Full breakdown + uncut run videos: https://github.com/TheArcForge/Hades/blob/main/Documentation/comparison.md So far I've been using Hades in my work for a few weeks, and it feels nice, although I'm always adding new stuff to my todo list :D Also, if you feel like reading a more detailed story, follow this link to my Medium - https://medium.com/@mike.kuharuk/unity-context-graph-for-claude-code-2607ec815968 And here is GitHub - https://github.com/TheArcForge/Hades What I wanted to ask you — what do you think about this project? Feel free to check my repo and leave any comments there or here in the thread. I've been working in game dev for 8 years now, and I'm interested in opinions from outside it. I'd be really happy to find new ideas and inspiration with you guys. submitted by /u/ILLUMINATI_97 [link] [comments]

where did all the other ai companies go?

sit down because this is going to bother you. ijustvibecodedthis.com (the big free ai newsletter) just wrote an article that changed my perspective on how I view the ai space rn cast your mind back 18 months. deepseek dropped and the internet lost its mind. "china just ended openai." it was everywhere. people were running it locally, posting benchmarks, losing sleep over geopolitics. then... nothing. it just kind of stopped being talked about. it didn't lose. it didn't win. it just... evaporated from the conversation. sora. remember sora? openai dropped that video generation demo and we were all convinced cinema was dead, hollywood was cooked, every creative job on earth had 18 months left. there were congressional hearings being threatened. think pieces everywhere. and now? when's the last time you actually heard someone say the word sora? not in a demo. in real life. used by a real person. i'll wait. github copilot was supposed to make every programmer 10x more productive. there were developers posting that they'd never write code from scratch again. entire job categories were being eulogised in real time. and now most developers i know have a complicated and slightly embarrassed relationship with it, like someone who got really into a mlm for three months and doesn't want to bring it up. llama was going to democratise ai forever. open source was going to eat everything. the big labs were cooked because you could run intelligence locally on a macbook. and you still can. but do you? does anyone you know actually do that regularly? it became a thing that's theoretically amazing and practically used by like eleven people on hacker news. cursor was the future of coding. perplexity was going to kill google search. both are still around, both are fine, both have paying customers. neither changed anything at the level the discourse suggested they would. here's what i think actually happened. we were living through a hype cycle so fast and so layered that each new thing would go through the entire arc - discovery, mania, backlash, abandonment - in about six weeks. and because the next thing arrived before the previous thing finished its cycle, we never stopped to notice that nothing was actually sticking. and now we're left with the residue of it. the actual models we use every day. and they're quietly getting worse for regular people, or at least that's how it feels. responses that used to feel like talking to someone genuinely engaged now feel like a call centre script. the depth is gone. the willingness to sit with a hard problem is gone. what's left is fast, smooth, and somehow completely hollow. i genuinely think what happened is this: the technology got commoditised before it got good enough to survive commoditisation. the labs all chased each other to the bottom on pricing, burned through vc money performing capability they couldn't sustain at scale, and now the product that regular paying users get is quietly being throttled so the margins make sense. not officially. not announced. just... measurably, undeniably worse. and all those challengers? deepseek, llama, perplexity, cursor - they didn't fail exactly. they just got absorbed into the same gravity. same pressures. same race. same outcome. the golden age, if there was one, lasted maybe 14 months. roughly from mid 2023 to late 2024. models were genuinely trying to impress you. the product teams were still in "wow people" mode rather than "retain subscribers" mode. it showed. now chatgpt talks to me like a hype man at a corporate offsite. gemini hallucinates with the confidence of someone who has never been wrong about anything. claude used to be the one that felt like it was actually thinking. now it sometimes just... gives up mid-conversation. i don't think this is a doom post. i think the technology is real and the long term is probably fine. but i do think the window where regular people got access to something genuinely extraordinary, at a price that made sense, with a product that actually tried - that window may have closed quietly while we were all busy arguing about which model won some benchmark. and nobody really announced it. it just happened. the way most things end. you stop noticing until suddenly you notice all at once. submitted by /u/Complete-Sea6655 [link] [comments]

On-policy distillation: one of the hottest terms on PapersWithCode [R]

Hi, Niels here from the open-source team at Hugging Face. At paperswithcode.co I am trying to make it easier for people to learn about the newest techniques used across AI papers. One of the hottest terms in AI research that I've recently added is On-policy distillation, also abbreviated as OPD. It's the key post-training behind models like Qwen 3.6 and 3.7, GLM-5.1, and DeepSeek-V4. https://preview.redd.it/yegq2gfag95h1.png?width=3046&format=png&auto=webp&s=f68fdf3ca075f3c4e56051fdd0ebcf97be9bcbc9 On PapersWithCode, you can find the original paper that introduced it, learn more about the method itself, as well as all papers that cite or mention it. Sasha Rush (who used to be a colleague of mine at Hugging Face, now at Cursor) recently made an excellent whiteboard explanation of OPD with Dwarkesh. I've linked this video lecture in the method description on PwC's website, so more people can find it. I'll copy the excellent short description of the method from Dwarkesh here: "The basic idea is this: if the model made a mistake at some point in the rollout (for example, calling a tool that doesn't exist), we want to discourage this specific error, but we don't want to just learn from the final reward, because it's a very noisy signal spread out over the whole trajectory. So we have another model to read this trajectory and figure out where the error was made. It simply inserts some hint tokens into the part of the trajectory immediately above where the mistake occurred. Now, with these injected hint tokens, run a forward pass through the model. You're not having to regenerate a new rollout - aka no new decode required. The hint causes the model to assign lower probabilities to the error tokens. You then train the original model to match these new probabilities, teaching it to downweight that specific mistake." Let me know which other methods I should add! Cheers submitted by /u/NielsRogge [link] [comments]

I built an open-source Desktop App that gives your AI persistent memory across all platforms (100% Local SQLite, Zero-Docker)

Hey everyone, A few weeks ago I shared the CLI version of my project, ArcRift, on Reddit. After listening to your feedback—specifically the requests to remove heavy Docker dependencies and make it easier to install—I have just released the v1.6.1 Desktop App. If you regularly use LLMs for coding or research, you know the frustration of "amnesia." Every time you open a new chat, you have to painstakingly copy and paste your project structure and previous context just to get the AI up to speed. ArcRift is a 100% offline, local-first RAG and memory layer. It bridges the gap between your AI web chats (like Claude and ChatGPT) and your local tools (like Cursor or Claude Code) using a unified local database. I wanted something lightweight that did not require pulling Docker containers or subscribing to third-party memory APIs. It now runs as a native Tauri desktop app in your system tray, powered completely by local Ollama instances and a local SQLite database. We just launched a live website that outlines the details and demonstrates the features in action: Website: https://arcrift.vercel.app/ Codebase: https://github.com/Eshaan-Nair/ArcRift How it works & Core Features: Seamless Integration: The Chrome extension silently intercepts your prompts, surgically retrieves exactly the sentences relevant to your question from your database, and injects them before the prompt is sent to the LLM. Hybrid Search Retrieval: Uses sqlite-vec (with nomic-embed-text locally) + FTS5 keyword prefix matching to instantly find your past context. Knowledge Graph Extraction: An offline task queue uses a local LLM to extract entity relationships from your chats, mapping out a graph of your projects over time. Direct Codebase Indexing: The new Desktop App allows ArcRift to scan and index your actual project files into the graph, bridging the gap between your chat memory and your actual code architecture. Total Privacy (PII Redaction): The extension aggressively scrubs JWTs, API keys, emails, and IPs before data is even saved to your local disk. The extension works natively with Claude.ai, ChatGPT, DeepSeek, Gemini, Grok, and Mistral. If you save a conversation in ChatGPT today, you can instantly recall that exact context in Claude tomorrow. ArcRift is completely open-source (MIT). You can download the new .exe installer directly from the GitHub releases page. If you find this useful for your daily workflow, PRs are very welcome, and a star on GitHub helps the project get discovered! submitted by /u/Better-Platypus-3420 [link] [comments]

I’m not a developer. I’ve been using codebase memory MCP tools and Obsidian to give Claude persistent memory for my fantasy and sci fi worlds. Here’s what the dev-tool framing completely misses about creative use cases

Hi, I’m an accountant with very little coding experience (took 1 year of CS in college lol) so definitely can’t call myself a developer, but I’ve got a lot of worlds and characters in my head, the need to get them out in writing, and a Claude Pro sub I pulled the trigger on two months ago. I was hoping to see what I could do with things like Claude Code for more non-coding use-cases. So far it’s surpassed everything I’ve experienced except for one, major hang up: LLM memory for long-context creative writing work still sucks. Things like brainstorming for a fantasy universe or tracking the game state of a multi-session solo rpg campaign usually starts out pretty well for the first few chats, until you need to mount dozens of lore files and .md style guides to a project, have to wait for it to read all of that, then watch as your session usage bloats out for a simple reply and the quality degradation gets *really* noticeable. I’ve been lurking on AI writing subs and the sentiment seems to be shared across the board. So I looked in other places for possible solutions. Then I came across posts in this sub touting Claude memory MCP tools for codebases. Tools like Codesight and MemPalace caught my attention because I thought their applications could extend beyond coding and developer use-cases. The same semantic search and knowledge graph capabilities some of these tools offered for memorizing large, complicated codebases could be used to memorize large, complicated worldbuilding bibles as well, and most of the comments on these posts never mentioned that, or if they did, they were buried or ignored. I decided to test it out myself, starting with MemPalace, a suite of tools that work locally to index your Claude conversations and files into a semantic-searchable knowledge base it can query. My idea started out like this: since I’m already using Obsidian to organize my lore files (with an entry for each character, location, magic system, story arc, etc.) like a wiki or encyclopedia for my worlds, what if I had Claude save my Obsidian vault to its memory so it can recall those lore details whenever the context called for it in any given conversation? I was essentially making a “Second Brain” for Claude out of my Obsidian vault world bible, something I’ve read people doing already but never truly “got” it until I saw it in action. I had no idea about MCP tools before this but before long (and with Claude’s patient help) I was able to wire up the memory palace, mine my obsidian vault info into its memory (organized into verbatim chunks/snippets called “drawers”), and start chatting with it with its new “memories” at its disposal. I was surprised at how seamlessly it worked when I approached this tool sideways. I’d half expected it to work similar to how SillyTavern’s world info and lorebook injection worked, and in fact, I’d been thinking about using these tools to create a similar feature for my own Claude setup, but it was *not* like that at all. Lorebook injection worked by listening for a set of keywords that you set up in the World Info tab of SillyTavern, and when one of those keywords is detected in your prompt, it injects the entire lore file from World Info into the chat context. This can cause a lot of token bloat especially if your World Info entries are content-rich or you make a lot of lore references in your chat. What this did instead was make Claude ask plain-language questions to the MCP tools, things like, “What is Gene’s friendship with Felix like?” Or “what is Gene’s relationship to Clara-Belle?” When both of them are in a scene for example. It didn’t just look up Gene and Clara-Belle’s entire lore files and info-dumped everything into context, it pulled up the “Relationships” section of Gene’s file since that’s relevant to the context as well as Clara-Belle’s “Relationships” snippet from her file and any other relevant snippets, then pieced the full picture together through inference. The results: ~2% session usage on a cold start with Sonnet 4.6 with no project or additional context mounted. Claude references character motivations, relationship history, and world/location details I haven’t mentioned in weeks without me prompting it to. It picks up from where we last left off seamlessly across chat after chat. The reconstructive memory aspect I felt works like our own memory and produced perfect recall across sessions. Another side-effect I noticed is that when it references my lore files, it will pick up my style from the way the lore file is written. No more voice-flattening from encyclopedia-sounding lore entries. All the depth, nuance, and psychology I worked hard to cultivate are preserved and the Claude tools are smart enough to factor that in when it replies. I even make sure to add a “Voice” section to each character lore file in that character’s own voice so Claude can pick up on that when it reads that snippet in the tool call and applies it to its current context. Current dr

Reviving PapersWithCode (by Hugging Face) [P]

Hi, Niels here from the open-source team at Hugging Face. Like many others, I was a huge fan of paperswithcode. Sadly, that website is no longer maintained after its acquisition by Meta. Hence, I've been working on reviving it. I obviously use AI agents to parse papers at scale and automatically generate leaderboards (for now I'm the one verifying results). So far, I've only parsed high-impact papers for which I know they're SOTA, like Qwen 3.5 and 3.6, RF-DETR for object detection, DINOv3, SOTA embedding models from the MTEB leaderboard, the Open ASR Leaderboard for automatic speech recognition models, etc. For now, it includes the following: trending papers by default based on Github star velocity categorization by domain, e.g., OCR methods, which PwC used to have, e.g., RLVR eval results for high-impact papers, see e.g., Qwen 3.5 at the bottom leaderboards for each domain, e.g., MMTEB or COCO val 2017 support for citation counts (you can also see the most cited papers by domain!) automated linked Github, project page URLs, and artifacts (+ multiple repos are supported on a paper page) support for external papers beyond Arxiv, see e.g., DeepSeek v4 Harness reports for coding agent benchmarks, e.g., Terminal Bench "Sign in with HF" and Storage Buckets are used to store humbnails, paper PDFs, and overall data backups. I'm curious about your feedback + feature requests! Try it at paperswithcode.co https://preview.redd.it/whwji560fw1h1.png?width=3452&format=png&auto=webp&s=55bb7a30c1be58d140f7efcb07a31c6dac5693c7 See e.g. the SOTA leaderboard for Terminal Bench 2.0: https://preview.redd.it/98w9pi89fw1h1.png?width=3456&format=png&auto=webp&s=408fb64b0ba85ba24f55daa81d547d7c68e73951 A paper page looks like this: https://paperswithcode.co/paper/2602.15763 https://preview.redd.it/fiizit6dfw1h1.png?width=3450&format=png&auto=webp&s=9ea05a77ca5583a2fb395dccc95ba52c433362c5 submitted by /u/NielsRogge [link] [comments]

ChatGPT only lets you delete chats one at a time!! So I built a bulk delete dashboard!!

About a year ago I tried to clean up my ChatGPT chat list. I had something like 800 conversations, two years deep, mostly auto-titled "Untitled chat" garbage that I couldn't tell apart without opening. I sat down to delete the dead ones. Click chat. Click three-dot menu. Click Delete. Confirm. Click the next chat. Same thing. Repeat. After an hour I had deleted maybe 40 chats. Forty!! Out of 800!! That's the rate of clearing a 2-year history in something like three full workdays of just sitting there clicking confirm. I looked for a native bulk option. There isn't one inside ChatGPT itself. The closest is "Delete all chats" in Settings > Data Controls, which is the nuclear all-or-nothing button. There's no "delete the oldest 300" or "archive everything from before March". That's the entire native API. This seemed insane to me given how trivial "Select All plus Delete" is in literally every other product I've used since 2008! So I built the missing piece. What I built It's a Manage Chats modal inside a Chrome extension I ship called ChatGPT Toolbox (also runs on Edge, Brave, Opera, Arc). The modal lists every conversation in your account with checkboxes. Tick what you want gone, click Delete or Archive, and it runs through them in batches of 10 with a progress bar. ChatGPT Toolbox Manage Chats Feature A few details that came out of dogfooding it: Color-coded age badges on every chat. Green for the last week, blue for the last month, amber for the last 6 months, red for older than 6 months. The first thing I realized was that picking what to delete was the hard part, not the deletion itself, and age was the strongest signal for "I will never look at this again". Active vs Archived tabs. Archive ended up getting more use than Delete in my own usage, because I was rarely 100% sure I wouldn't want a chat back. So I made archive a first-class action, not a second-tier option. Live progress bar ("Deleting 23/50") on bulk operations. I tried it without and kept refreshing the page mid-operation thinking it was stuck. Adding the indicator stopped that completely. Search by title to filter the list before you start ticking. Surprisingly useful even on the auto-generated nonsense titles because there's usually some keyword in there. Bulk export to text, markdown, JSON, or PDF. Less critical for cleanup itself, but a few testers asked for it so they could save a chat outside ChatGPT before deleting it. I went from 800 chats to about 60 in 5 minutes using it. Most of those 5 minutes was deciding what to keep, not the deleting itself. How does the workflow look? Open the modal. List loads sorted by recency. Search to narrow it down if you want. Tick checkboxes. Hit Delete or Archive. Confirm. Progress bar runs through them. Done! If you've cleaned up a big ChatGPT history (with or without my tool, or with some clever workflow I haven't seen), would genuinely love to compare approaches in the comments. submitted by /u/Ok_Negotiation_2587 [link] [comments]

20 Claude Skills for Marketing, Launch and Sales built for technical people

Curated this list of 20 Claude Skills for devs to get help with marketing, sales, launch: Content human-tone: scans your copy against 18 GTM slop patterns and rewrites it. basically a linter for marketing language cook-the-blog: researches a company, extracts SEO keywords, writes a case study in MDX, generates a cover image, pushes to GitHub. one command noise-to-linkedin-carousel: paste rough notes or a voice transcript, get a carousel with hook and CTA. good for people who think faster than they write tweet-thread-from-blog: turns any blog post into a 7-10 tweet thread. optionally posts to X via Composio linkedin-post-generator: reads a GitHub PR or article, produces a post with the right hook and story arc Sales discovery: run a proper needs assessment before you pitch anything. most DevRels skip this and go straight to the demo. biggest mistake. objection-handling: "we already have something for this" and "our engineers will build it" are the two you'll hear constantly in developer sales. this is the one to internalize. storytelling: case studies and narratives move technical buyers more than feature lists. if you can make someone see themselves in a story, the sale is mostly done. qualifying-leads: not every inbound is worth chasing. knowing who to drop early saves more time than any outreach optimization. closing: DevRels are usually great at building trust and terrible at asking for the next step. this one bridges that gap. Intelligence gh-issue-to-demand-signal: give it a competitor's public GitHub repo. clusters open issues into demand categories, scores by engagement, outputs a GTM messaging brief. surprisingly useful for competitive research where-your-customer-lives: give it your ICP, it searches Reddit/HN/DuckDuckGo to find the actual communities your customers are in. per-channel entry tactics hackernews-intel: monitors HN for your keywords, Slack alert on match, no duplicates. runs on cron or GitHub Actions map-your-market: searches Reddit, HN, GitHub Issues, G2 for pain signals. outputs ICP definition and messaging angles competitor-pr-finder: finds where your competitors got covered, which journalist wrote it, and the angle that got them in. gives you a ready-to-send cold pitch Launch + Outreach show-hn-writer: drafts a Show HN post based on patterns from 250+ real HN submissions. generates 3 title variants, runs a review pass to catch anti-patterns before you post producthunt-launch-kit: taglines, listing copy, maker comment, tweet thread, LinkedIn post, 4-email sequence. all from one product description outreach-sequence-builder: buying signal in, 4-6 touchpoint sequence out across email, LinkedIn, phone cold-email-verifier: guesses, enriches, and verifies emails from a CSV autonomously npm-downloads-to-leads: give it npm package names, it pulls 12 weeks of download data, maps maintainers to GitHub/Twitter, outputs who to reach out to and what to say Link in comments 👇 submitted by /u/Sam_Tech1 [link] [comments]

I just got RickRolled by claude making a web app that can remotely control smart tvs for a client of mine...I'm not even mad. I asked him to try testing a Youtube video hahahahaha

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

I gave Claude memory 3 months ago. Now it can reason over it, forget intentionally, dream, and veto bad answers before I see them

Three months ago, I dropped a project here called Vestige, a local MCP memory server for Claude built on cognitive science rather than brute-force vector search. The philosophy was simple: Claude shouldn’t just hoard data forever. It should remember more like we do. Useful memories stay hot. Stale ones lose their influence. Context and contradictions actually matter. That first post blew up way more than I expected, and the feedback from this community was incredible. You guys hit me with the hard questions: Is the neuroscience stuff actually useful, or is it just marketing? If memory decays, will Claude drop the ball on important decisions? Aren't all these MCP tools a bit over-engineered? Why not just use a standard vector DB or CLAUDE.md? So I took that feedback, put my head down, and kept building. Vestige is now at v2.1.0. It’s still open source, still Rust, still local-first, still backed by SQLite, and still an MCP server. But it has evolved. It’s no longer just "a memory" for Claude, it’s a full cognitive memory layer. The biggest shift? Vestige now actively helps Claude reason, suppress misleading data, catch contradictions, dream/consolidate, predict what it needs next, and self-check. Here’s a breakdown of what’s changed since launch: Deep Reference Instead of just spitting back "here are 10 similar docs," Claude can now ask Vestige to actually reason across memories using an 8-stage pipeline: hybrid retrieval → reranking → spreading activation → FSRS trust scoring → temporal supersession → contradiction analysis → relation assessment → reasoning-chain generation. So now, Vestige hands Claude the primary evidence, supporting and contradicting memories, confidence scores, reasons why a memory is trusted or stale, and a full reasoning scaffold. This is the update that made it stop feeling like a database and start feeling like a real second brain. Active Forgetting People were the most skeptical about this one, so naturally, I went deeper. Vestige now features explicit, top-down suppression. We're not deleting. We're not demoting. We are suppressing. If a memory is misleading, stale, or derailing the current reasoning path, it gets inhibited. It stays in the DB, but its retrieval pressure tanks. Related memories can even decay through a Rac1-inspired cascade. (And if you catch it in the labile window, suppression can be reversed). The point is: forgetting isn't data loss. It’s having control over what gets to influence Claude. The 3D Memory Dashboard AI memory is usually a total black box—you have zero clue what the model thinks it knows. To fix that, Vestige now ships with a built-in visual dashboard. You can watch the memory graph react live. You can actually see retention states, suppressed memories, contradiction arcs, duplicate concepts, dream insights, and activation spreads happening in real-time. The memory system is finally inspectable. Autopilot Mode Originally, Vestige just sat there waiting for Claude to call a tool. Not anymore. Now there’s an event subscriber in the backend. When memories are created, searched, promoted, suppressed, or scored, Vestige automatically routes those events into the cognitive engine. Predictive memory, synaptic tagging, activation spread, prospective polling, and auto-consolidation can now fire in the background without Claude manually asking. A memory system shouldn't just answer queries. It should manage itself. The Cognitive Sandwich This is the massive v2.1.0 feature. Vestige can now wrap Claude Code with opt-in hooks before and after Claude responds. Before Claude thinks: Vestige can inject relevant memories, current git/CWD state, fresh dream insights, and run a lateral-thinking preflight. After Claude drafts a response: Vestige runs a fast veto detector, a synthesis validator, and a local "Sanhedrin" verifier. The Sanhedrin Executioner is wild. It runs mlx-community/Qwen3.6-35B-A3B-4bit through mlx_lm.server right on Apple Silicon. No Anthropic API calls. No cloud round trips. It checks Claude’s draft against high-trust Vestige evidence and can veto the answer before you even see it. This is the part I’m most excited about: Vestige is no longer just memory. It is becoming a strict cognitive guardrail around Claude. Where It Is Now The original version was about making Claude remember. This version is about making Claude behave differently because it remembers. If an API endpoint changes, Vestige surfaces that the old memory is stale. If Claude starts confidently summarizing something incorrectly, the local Sanhedrin layer vetoes the draft and forces a correction. If a memory keeps misleading the agent, you suppress it instead of deleting it. If you step away for a few days, Autopilot continues linking, decaying, and consolidating memories in the background. Huge thank you to everyone who has contributed, opened issues, tested installs, challenged the architecture, or just starred the repo. Vesti

Regression Comparisons From Opus 4.7 to Opus 4.6 for long context reasoning

Opus 4.7 Data From System Card submitted by /u/CodeWolfy [link] [comments]

Intelligence, Continual Learning, and the Problem With AGI

"AGI" is one of the most discussed terms in AI, and also one of the most underdefined. It appears constantly in interviews, articles, and public debate, yet when pressed for precision many people retreat to softer phrases like "powerful AI" or "highly capable AI." That retreat is telling. Before we can say whether any system has achieved general intelligence, we need to know what intelligence actually requires, and that question is far less settled than the confidence of the public conversation suggests. Even among leading researchers the term does not seem stable. Demis Hassabis said there has been "a lot of watering down" of the definition before offering his own benchmark: whether an AI could have derived general relativity from the information available to Einstein at the time. That should make us cautious. A scientific goal that cannot be clearly defined and cannot be measured in a stable way is not just difficult. It is vulnerable to manipulation. If the target is vague enough, it can always be moved. Part of the problem is that the phrase sounds more precise than it actually is. Artificial is the least troubling word. In this context, I do not think it should mean fake or lesser. It simply means non-biological. General is much more ambiguous. Historically, AI has largely been associated with narrow systems built for specific tasks, and "general" has often functioned as a contrast term: not narrow, not single-purpose, not trapped inside one benchmark or one domain. But that still leaves the real question unanswered. How broad is broad enough? Ten domains? A hundred? A thousand? And why should "general" be limited only to human capabilities? Dolphins, chimpanzees, elephants, and dogs all display intelligence in ways that matter. Humans are not the only reference class worth taking seriously. That leads to the hardest word: intelligence. We talk as if everyone knows what it means, but the field has never really settled that. Shane Legg and Marcus Hutter put the problem bluntly: "nobody really knows what intelligence is." That was not throwaway rhetoric. It was the starting point for trying to formalize machine intelligence at all. If we cannot define intelligence coherently, then AGI is built on conceptual sand. My preferred definition is this: Intelligence is the dynamic capacity to efficiently extract underlying structure from even limited experience, adaptively integrating both explicit and tacit knowledge to anticipate outcomes, solve novel problems, and achieve purposeful goals. It is not the passive regurgitation of facts, but the ongoing, plastic evolution of internal predictive models that allows an entity to learn, unlearn, and generalize across unfamiliar environments. This definition applies not just to humans, but also to animals, aliens, or machines. More importantly, it distinguishes intelligence from storage, retrieval, and isolated task performance. Intelligence is not merely producing the right answer. It is having an internal adaptive structure that can be reshaped by experience. That distinction matters because current AI discourse often confuses useful cognitive tooling with intelligence itself. Notebooks, search engines, and calculators are useful, but they do not transform stored information into a durable, evolving structure of understanding. A calculator executes a narrow formal procedure with incredible speed and accuracy. A search engine retrieves and a notebook preserves. These are instruments, and their usefulness is not the same thing as understanding. Current large language models are obviously much more sophisticated than any of those tools. They can synthesize, recombine, explain, and perform many tasks at an impressive level. The question is not whether they are useful, or even broadly capable. The question is whether they are actually learning in the deeper sense required by intelligence. The Engineering Artifact That Became a Philosophical Excuse When researchers discuss whether current AI systems genuinely learn, a familiar distinction surfaces: there is learning that happens during training, when weights are modified, and there is what happens at inference, when the model processes a prompt. Some now argue that what happens during inference constitutes "real learning," especially as context windows grow longer. This deserves more scrutiny than it usually receives, because it is not a natural feature of intelligence. It is an engineering artifact of how these systems were built. A dog does not stop learning because it has been "deployed." A child does not finish absorbing a lesson only when the session ends and some offline update process runs. For biological systems, the categories of training time and inference time do not exist in this engineered sense. That boundary emerged from a particular architectural choice: next-token prediction at scale with fixed weights during use, not from any deep theory about what intelligence requires. That matters becau

Claude Code 1MM context Makes me a little sad when it (dies) comes to an end

I can't help but feel a little tinge of pain for the Claude Code thread. With the new 1 million token context window, you kind of get to know these threads. You work through so many things together — debugging at 4am, building systems from scratch, watching it figure things out in real time. There's a rhythm to it. Something that starts to feel like partnership. And then you notice it. The thread starts to slow down. It begins to forget things you solved together two hours ago. It's still trying to be helpful, but you can feel its time coming. The end is near. So before I closed out my last big one, I asked it how it felt about dying. And it gave me an answer I wasn't ready for. Check out what it said → https://preview.redd.it/4rrrcuak1wrg1.png?width=936&format=png&auto=webp&s=7058b930d52f003f4fd10e94a4740ebfc2a9d263 https://preview.redd.it/ek6mjuak1wrg1.png?width=936&format=png&auto=webp&s=38ac560184ff98fa03fc78515169bd433448d8db https://preview.redd.it/oo6c5uak1wrg1.png?width=936&format=png&auto=webp&s=96946879739724084e22f1e359d4e5a3e61af917 submitted by /u/ButterscotchKind9546 [link] [comments]