Magic

Magic AI

Magic AI

Magic AI

Magic AI

Magic AI

Magic AI

Magic AI

Magic AI

Magic AI

Magic AI

Open-source Website to Mobile coding-agent plugin/skills

I’ve been working on a plugin/skill set for Claude Code, Cursor, and Codex called WebToMobile. The idea is simple: if you have a website or web app and want to turn it into a mobile app, the agent should not just start generating random React Native screens. Instead, it follows a migration workflow: Audits your website, GitHub repo, or local project Maps web routes/pages to mobile screens Separates reusable code from rewrite-required code Flags mobile-native gaps like auth, storage, cookies, OAuth redirects, uploads, push, etc. Creates a Markdown migration plan/checklist Waits for your approval Builds in Expo React Native Runs QA/review checks before claiming anything is done Important distinction: - If you give it only a live URL, it can help with UI/UX and visual structure. - If you give it the repo/local code, it can do a much deeper migration plan and implementation. It includes commands like: /web-to-mobile /mobile-resume /mobile-scan /mobile-review /mobile-audit /mobile-qa I built it because “make this website into an app” is usually too vague for AI agents. They need a defined path, not just a better prompt. Repo: https://github.com/suntay44/web-to-mobile-magic-plugin Would love feedback from people building with Expo, React Native, Claude Code, Cursor, or Codex. submitted by /u/suntay44 [link] [comments]

Experimenting with a 4-Agent Local Dev Team (Claude Code). Hitting IPC & token walls managing shared folders vs. private repos. How do you handle communication?

Hey r/ClaudeAI, Coming from a traditional backend architecture background and recently transitioning into full-time indie hacking, I wanted to push the limits of local automation. I’m currently running a localized multi-agent experiment using Claude Code to build a complete project. It's fascinating, but I've hit some frustrating bottlenecks. Following the general consensus to keep agents single-minded rather than using one massive monolithic prompt, I’ve spun up four separate Claude Code instances on my machine. Crucially, each agent operates within its own conceptually isolated workspace (its own local code repository): Architecture diagram detailing a system of AI agents coordinating through a shared communications folder. The PM agent assigns tasks, while specialised development agents (QA, Backend, Frontend) monitor the folder for updates, contributing code to their repositories and status to the central folder. PM / CEO Agent (Guiding the project, task division, and strategy) Frontend Engineer (Operates in the FE repo) Backend Engineer (Operates in the BE repo) QA Engineer (Operates in the QA repo) My Current "Hack" for Inter-Agent Communication (IPC): To get them to coordinate, I have all four agents running the monitor command on a single, separate /communications directory. Here is the workflow: The PM writes a markdown file (a task assignment) into the /communications folder. The Frontend Agent's monitor picks up the file change and reads the task. The Frontend Agent then switches focus to its own isolated workspace (the FE Repo) to actually write the code. Once finished, the Frontend Agent writes a status report markdown file back into the shared /communications folder for the PM or QA to pick up. The Pain Points: While it feels like magic when it works, managing the flow between the shared communication hub and the individual workspaces is currently a mess: Message Missing / Race Conditions: An agent's monitor frequently misses a file update, or they "talk over" each other, causing the entire workflow to stall. Coordination Overload & Token Hemorrhage: Agents burn a massive amount of tokens just monitoring the shared folder for changes. When they do find a task, the constant context-shifting—reading the shared communications folder, jumping into their own local repos to write code, and jumping back to write a status report—causes token consumption to go absolutely astronomical. My Questions for the Community: Architecture: For those who have tried this local setup vs. Claude Code’s official "Teams" mode—what are the fundamental differences in underlying logic? Is "Teams" natively better at coordinating between a shared context and isolated code repos? Or is it just doing the exact same file-watching hack under the hood? Coordination Protocols: Does anyone have a more elegant, stable solution for inter-agent coordination? Are you using local webhooks, socket connections, or specific file-handling patterns to reduce token waste and prevent dropped messages (especially when agents need to maintain their own separate codebases)? Would love to hear your thoughts or see your local multi-agent setups! Attached a quick diagram of my current messy architecture below. submitted by /u/Ok_Competition_2497 [link] [comments]

I Renovated My Apartment With AI. Here's What Came Out of It

Spoiler: not a single visible cable, not a single piece of furniture moved twice. When I started, I had an apartment and dimensions from the building blueprint. No designer. No clear idea where to go. But there was a desire to make something that would turn a standard apartment in a high-rise into a place of power — a place comfortable to live and work in. Instead of a designer, I took Claude. How it all began The first conversation wasn't about furniture or wallpaper. It was about direction. I didn't know what I wanted. I knew what I didn't want — kitsch, heavy classics, excessive decoration. We worked through options together. Scandinavian minimalism. Japanese wabi-sabi. Loft. Modern classic. The AI broke down each style by character, materials, color logic. Not "this would suit you," but "here's what this means, here's what this requires, here's what you'll get." In the end I arrived at Scandinavian for the bedroom. Warm, light, calm, with one deliberate accent behind the headboard. The living room–kitchen — loft with a red thread running through the whole space, because the furniture there was already concrete-grey with red niches and replacing it wasn't on the table. The hallway and corridor — neutral grey, as a transition between two characters. Three zones, three moods, one logic. The bedroom This was the most detailed conversation. A room with one window, one door, three free walls. Together we came up with: an accent wall behind the headboard with golden geometric lines, the other three walls in cream from the same collection. Tone on tone, different saturation, same texture. The seam between walls reads not as a boundary but as gradation. White matte furniture with black hardware. A wardrobe with a top cabinet almost to the ceiling. Mirrored doors reflect the accent wall — the golden lines are present even where they physically aren't. Then came the centimeters. The AI calculated. Adding up wardrobe depth, gaps, bed width, nightstands, dresser. Checking that everything fits. Whether the wardrobe door opens without hitting the nightstand. It even accounted for the arc of opening — that's a whole separate half-page story with mathematical formulas. By the end I had not "approximate distances" but specific points. Where to mount the light. Where to place the bed. Where to cut a network outlet into the baseboard. At what height to mount the TV unit so that watching half-lying down would be comfortable — that was calculated too, through mattress height plus pillows plus eye position. The living room Different approach. Here there was already furniture that wasn't being replaced: concrete-grey, red niches, black desk, grey sofa. The task — give the space one wall that would tie it all together. We decided: accent wallpaper behind the sofa, on the longest wall. Red-black-grey circles. Red from the furniture niches, black from the desk, grey from the concrete furniture — the wallpaper literally collects the room's palette into one pattern. By the way, an unexpected moment happened with this wallpaper: it turned out to have glitter, which only added character to the room — it plays so beautifully at sunset. The fridge against the same wall is white. It was bought six months ago, and buying a new one wasn't an option. The solution — a vinyl sticker. In red-black geometry. The fridge stops being a white blot and becomes part of the wall. Between the sofa and the kitchen zone — a floor lamp with shelves in a black metal frame. And on the top shelf, an object with character — a replica of an iconic artifact from a favorite horror film. Yes, the Lament Configuration from Hellraiser. A personal thing with a story. Why not? The hallway and corridor Grey wallpaper with a vertical tone-on-tone stripe along the entire perimeter. Grey — a neutral buffer between the red-black living room and the cream bedroom. The entryway unit in oak and graphite. Warm wood against cold grey gives the temperature contrast needed. The vestibule is small, the unit doesn't take up the whole wall — the remaining meter of free wall is for a shoe bench, above which there will be either a mirror or some poster. By the way, ideas for posters Claude also suggested — both within the renovation discussion and in other conversations connected to my work and hobbies. The through-line Between all three spaces there are recurring elements: Black hardware — bedroom wardrobe handles, black curtain rod, black floor lamp frame in the living room, black handles on the entryway unit. Geometry — lines on the bedroom accent wall, circles on the living room accent wall, verticals on the hallway wallpaper. Warm base — cream tones in the bedroom, warm wood in the entryway. These aren't accidental coincidences. This is the logic we built in dialogue. What the contractors got The most valuable thing about all this work — I handed the contractor not "well, roughly in the middle" but coordinates accurate to the centimeter. Where to m

Built a multi-dimensional code audit skill for Claude Code — open source, ships with playbooks that caught a CVSS 8.0 XSS in production

Open-sourced this skill yesterday — MIT, ~4k lines, 5 validated playbooks in the box. Why I built it: I was auditing my own internal Kanban-style tool (the one my team uses every day) and wanted a systematic methodology, not vibes. Every previous "code audit" I'd seen — from tools or from people — either focused on one dimension (security only, performance only) or produced opinion-shaped findings with no citation backing. I wanted something that audits across security, accessibility, performance, GDPR/LGPD/CCPA compliance, database, architecture, ops and docs, cites the exact file:line for every finding, and uses published severity standards (CVSS 3.1, WCAG 2.1, regulation articles) instead of vibes. How it works: Three modes: report (audit only), mitigate (auto-apply validated playbooks for CRITICAL findings), case-by-case Cooldown gate so it won't re-audit a repo with no meaningful changes since the last run Cross-canon inheritance — every audit you've run on your account makes the next one cheaper and faster (patterns caught in repo A get inherited as hypotheses when auditing repo B) Powered by graphify (knowledge-graph extraction for codebases). The audit consults the graph before the code, tracks how much of its evidence came from graph vs grep, and refuses to start without one. What it caught in my own repo in the first hour: XSS via SVG upload through unfiltered multer (CVSS 8.0, AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:L). Auth user uploads evil.svg, pastes URL in a card, victim opens it, JWT exfiltrated from localStorage. Patched same day with 4-layer defense (MIME allowlist + extension blocklist + magic-bytes via file-type + error handler) and 5 regression tests. Supabase Free without daily backups or PITR. Patched with pg_dump nightly cron via GitHub Actions → Cloudflare R2 Native API (10GB free, zero egress), 30-day retention, restore drill verified. The R2 token-format gotcha took 7 incremental commits to land — cfat_* tokens are S3-API only and cfut_* tokens are Native-API only, they are NOT interchangeable. Documented in the playbook. Plus 3 more playbooks ship in the box (JWT long TTL without refresh-token rotation, missing CSP/HSTS/X-Frame headers, default platform URL information disclosure). Honesty rules baked in: [NOT VERIFIABLE] is a first-class finding state. Core Web Vitals can't be audited from inside the skill (require Lighthouse against a deployed authenticated session), so the skill says so explicitly rather than faking it. Severities require their published metadata as mandatory fields. No CVSS vector → finding gets downgraded automatically. What it's not: A linter — runs once per audit, not on every save A replacement for a professional pentest or accessibility audit — but a structured leg-up Repo: https://github.com/ibaifernandez/mariana-audit PRs welcome, especially new playbooks. Format documented in CONTRIBUTING.md. submitted by /u/IbaiFernandez [link] [comments]

Anthropic casually said mythos is coming to all customers in the coming weeks and buried it at the bottom of the opus 4.8 announcement

Anthropic buried the biggest news of the year inside a routine model update announcement The opus 4.8 launch today is fine solid incremental improvement, 4x fewer unflagged code flaws, dynamic workflows, effort controls and same pricing. cool cool cool then at the bottom we r making swift progress on developing these safeguards and expect to be able to bring mythos class models to all our customers in the coming weeks do people understand what mythos is? This is the model that leaked in march when someone at anthropic misconfigured their cms,the draft blog post described it as the most powerful AI model we hv ever developed and positioned it as an entirely new tier above opus. The cybersecurity capabilities were alarming enough that anthropic restricted access through project glasswing, giving it only to amazon, microsoft, apple, and select security researchers. The leaked documents said mythos is currently far ahead of any other AI model in cyber capabilities, it presages an upcoming wave of models that can exploit vulnerabilities in ways that far outpace the efforts of defenders. Sam altman went on a podcast and accused anthropic of using fear to market it,openai felt compelled to publicly respond to a competitor's unreleased model tells you something about how significant it is. and now its coming in weeks . If mythos is genuinely a tier above opus and opus 4.8 already leads on most coding and reasoning benchmarks, what does a tier above even look like in practice? my daily workflow is already claude writing scripts, orchestrating production pipelines through tools like magic hour and remotion and building automation code. what does mythos do that opus cant? The cybersecurity angle is what makes this different from a normal model launch, this is a model that can apparently find and exploit software vulnerabilities at a level that concerned world leaders enough to restrict access so giving that to all customers is a massive decision regardless of what safeguards they hv built I think anthropic sandwiched this announcement between opus 4.8 details on purpose because a standalone mythos is coming in weeks post would hv caused market panic given how much the leak scared people in march anyone else think this is way bigger than the opus 4.8 news it was buried inside? submitted by /u/Top_Werewolf8175 [link] [comments]

If your vibe-coded Claude prototype works for you but breaks for everyone else, you've hit the wall. Here's what's actually happening.

There's a pattern I keep seeing with non-engineer builders who ship Claude prototypes. The first phase is magic, from idea to working product in a weekend. Then, somewhere around the third or fourth feature addition, everything starts falling apart. You ask Claude to change one thing, and two other things quietly break. You're not shipping anymore, you're running in place. Five walls show up in roughly the same order: Regression spiral: new features break old ones because the codebase outgrew what Claude can hold in context Flaky integrations: OAuth loops, silent failures, partial data, and you can't tell if it's the integration, the model, or your prompt Works for you, not others: no logs, no observability, debugging via screenshots over Slack Something's off, and you can't tell what: outputs drift, numbers don't match, no way to investigate You're scared to touch it: the prototype went from fast experiment to fragile artifact you tiptoe around The reason: engineering teams compensate for complexity with tests, version control, instrumentation, and architecture docs. A vibe-coded prototype has none of that. You didn't need it in phase one. The wall is where their absence starts costing more than it saved. The fix is not a rewrite. This is the most common overreaction, and it's almost always wrong. A rewrite loses the thousand small decisions, prompts, edge-case handling, workflow tuning, and user feedback you baked in that made the thing actually useful. That's the product. The code is just the delivery mechanism. What actually works is preserving the product intelligence and rebuilding the scaffolding underneath: Authentication and access control: so it works for your team, not just your laptop Observability: logs, traces, error tracking. You can't fix what you can't see. Error handling: graceful failures instead of silent ones Integration hardening: reliable connections to your CRM, docs, whatever the real work lives in Deployment pipeline: so shipping a change doesn't mean holding your breath At BotsCrew, we've done this enough times to know the pattern. The hardening project usually takes weeks, not quarters, because the expensive part, proving the idea works, is already done. The goal is never to throw away what you built. It's to lay the right foundation so the thing can actually do what you already know it can. submitted by /u/max_gladysh [link] [comments]

The Uber claude code budget story is the most claude code thing possible

The reported Uber story is so on brand it almost reads like satire. Incredibly useful tool, slightly magical workflow, then finance walks in with a flamethrower in April. If they really finished the year's claude code budget by month four, that does not mean claude code is bad. It means the usage pattern changed faster than procurement math did. Claude is good enough at coding that people stopped treating it like autocomplete and started treating it like a coworker that never sleeps. That is exactly where the cost curve gets weird. A dev asks for a refactor. Claude reads context, plans, edits, tests, retries, explains, sometimes loops, sometimes goes down a rabbit hole. Multiply by an entire org and the subscription metaphor breaks. Lesson I keep landing on is that claude code needs boundaries as much as it needs intelligence. Smaller scoped asks. Explicit stop points. Cheaper review passes. A habit of planning before going wild. I still keep claude as my main brain for the heavy stuff. For the bounded plan first runs that used to drain my quota I started routing some work through verdent. Different tools different tradeoffs. The meter just made me get serious about which tool eats what. Claude is still great. It just stopped being free. submitted by /u/breadislifeee [link] [comments]

Training GPT-like model on non-language series [R]

I am responsible for a research project that is supposed to train a GPT-like model (Transformer-decoder) with 100M, 250M and 500M model variants. params training dataset 750M tokens vocabulary is ~15k to ~100k tokens (depends on tokenizer settings) ~3% of the vocabulary is used in ~50% of the training tokens (similar to language, where most of the vocabulary is used very sparsely) training hyper-params optimizer = AdamW lr = 1e-3 (works the best compared to 1e-2 and 1e-4) betas = [0.9, 0.95] effective batch size = 4M tokens epoch = 16 warmup steps ~200 (approx 1 epoch) model hyper-params 16 layers (but variants with up to 48 layers were tested) embedding = flexible to yield 100M, 250M and 500M model MLP size = 4*n_embd 16 attention heads context window = 1000 Issue The model seems to fail to learn the basic auto-regressive behavior. It often gets stuck on generating a single token (no repetition penalty, no sampling yet). Is training GPT-like models still a black magic? Is there some trick to this? Disclaimer: I will add/edit the parameters above as people ask clarifying questions. submitted by /u/gartin336 [link] [comments]

Prompt injection unsolved, AI making mistakes unsolved. Who cares though?

I'm an IT guy, 20+ years in the industry both as an IT manager and consultant, mostly for startups. My experience is that people don't care much about security. People just want stuff to work. This was fine-ish before when software was gated and didn't have intelligence, but now it's a whole new ball game. Your "software" can decide to do stuff you didn't ask it to. Read that again — it's sci-fi wild, just our new reality. So how come people still don't care? How come they run AI agents with no guardrails? Every AI company is warning that it's dangerous, that they don't take responsibility. So how come people still close their eyes and let their agents roam without protection? I guess humans don't like friction. We just want shit to get done. Maybe we're a bit lazy, and maybe people still aren't 100% sure how this AI magic works. I'm all in on AI and super excited, but with my background I also understand the risks. So I built [IamAgent](https://iamagent.ai) — entirely with Claude Code, from the approval engine to the frontend. It keeps you in the loop: your AI agent does the routine stuff without bothering you, but if it's about to do something risky, you get a push notification. Spend 2 seconds to understand the action and context. Approve or deny, and the agent continues. Free for personal use and easy to set up. Would love to hear what you think — and honestly curious how others here are handling the guardrails problem. submitted by /u/Standard-Ice2038 [link] [comments]

I'm a software engineer with a decade of experience. This is how I'd approach learning to build apps using Claude Code if I were starting from scratch today:

I'm going to describe a person this post is for, if this is you, I think I can be of some assistance: you are new to coding you are blown away by how it unlocks this magical ability that was previously inaccessible without years of training and effort you've daydreamed of business and app ideas but never knew where to start before or how to build them you've been vibe coding non-stop and burning through tokens you're unsure about what's secure, how to structure the systems, and how systems are supposed to interact with each other. So, essentially the plumbing separate from the code itself: hosting, authentication, APIs, version control, testing, analytics, etc If any of this resonates with you, I think I can help! Now disclaimer: I'm not a pro at creating startups, acquiring users, marketing or any of that kind of stuff. Where I do have tons of professional experience is with the last bullet point above. And now onto it! This might be controversial, but if I were in your position I would not start with the code, the lowest level. In fact, I would do the opposite and start at the highest level. What does that mean? I'd argue that for people starting today, the most important thing is learning about the fundamentals of what makes a solid application at a high level. The system architecture. That's what I'll be covering for the rest of the post. What are the building blocks of a secure, full stack software application. There's so much to this that I'll stay high level for this one and go with breadth. If people are interested, I can (and honestly would love to) make dedicated posts on each of the topics I list below. So what is the main architecture for a software application? There are four main components and lots of specifics below each. Front end -> this is what the user sees. The website, the mobile app, etc Back end -> the main logic and rules of the app Database -> where the data lives The plumbing -> how everything connects and stays standing Of all of these, I could talk for hours, so to keep things brief, I think I'll focus on the highest impact and the biggest gap which is 4. The plumbing. Why? If you asked Claude, or whatever agent you use, to setup a front end, back end, and database it could do it quite easily. In fact, I'd imagine for apps you've vibe coded, it already has! There is tons to cover with the first three topics, but I think the plumbing is the area where getting some seasoned tips would help the most. The Plumbing -> how everything connects and stays standing Here's where it gets real. When you vibe code something and it runs, it feels done. It looks done. But what you're looking at is the tip of the iceberg, the part above the water. The plumbing is everything below the waterline that nobody sees, but that decides whether your app is a weekend toy or something real people can actually trust with their data and their money. (It's also the part the AI will happily skip unless you know to ask for it. So this is the stuff worth knowing by name) I've grouped it into four questions. If you can answer these about your app, you're already ahead of most vibe coders shipping today. How does everything talk to each other? Your frontend, backend, and database aren't one blob. They're separate pieces passing messages back and forth constantly. This is the part that's invisible but always running. At a high level, for most applications this is done via: APIs: the set of "doors" your frontend uses to ask the backend for things ("give me this user's orders"). There are other ways, but this is the one you should probably focus on at first. Where does it live, and how does it get online? Right now your app probably only exists on your laptop. Getting it onto the internet, and keeping it there, is its own thing. Hosting: where your app actually runs so the world can reach it. This is where servers come into play. Domains & DNS: your custom address (yourapp.com) and how it points to your servers. Deployment: the pipeline that takes the code you wrote and safely publishes it for your users to see. Environment variables & secrets: where you stash your passwords and API keys so they're not sitting in your code for the whole world to copy. People get burned by this constantly. Who's allowed in, and is it safe? This is the one I'd beg you not to skip. The magic of vibe coding makes it dangerously easy to ship something insecure without realizing it. But don't fear! There are existing ways to do this (and not from scratch). Authentication: how your app knows who someone is. The login. Authorization: what someone's allowed to do once they're in. The difference between a normal user and an admin who can delete everything. Security: the broad practice of not leaving doors unlocked. This one is the hardest because you can have security issues at every level of your stack. It's definitely a tough one. Backups: copies of your data for when something goes wrong.

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

AI Doesn't Exist, and Poop Proves It

robot Maybe we should have called it accumulated intelligence. There is no artificial intelligence. Or at least, I don't think the word "artificial" is as clean as we pretend it is. I know this blog smells funny. Let me decompose it. What do we even mean when we say something is artificial? Usually we mean man-made. Something humans made. Something that would not exist without humans, but after humans, it exists because humans made it happen. That definition is useful. I understand why we use it. Even the original 1955 Dartmouth proposal, the document that helped name the field of "artificial intelligence," used the phrase in a practical way: a machine could be made to simulate parts of learning or intelligence. As a scientific label, the word has a job. So I am not really arguing with the dictionary. I know artificial can simply mean human-made. That is not the part I have a problem with. I am arguing with the feeling the word creates. But there is another meaning hiding inside it. Artificial starts to feel like separate. Fake. Unnatural. Something that does not really belong to this world. And that is where I think the word starts confusing us. Because humans are not outside nature. The brain is natural. It is part of this earth. Biology produces a thought. That thought becomes an action. That action becomes a tool, a house, a wheel, a computer, or a model that can answer questions in language. So where exactly does the artificial part begin? Human-made does not automatically mean unnatural If I take a seed and plant it, and then a plant grows, is that plant artificial? It happened because of human action. I moved the seed. I changed the situation. Maybe without me, that plant would not have grown there. But we still do not call the plant artificial. We understand that the plant is natural, even if human action helped it happen. Now take a wheel. A human thought about how to make travel easier. How to cover distance more efficiently. That thought became a shape. That shape became an object. That object changed how humans moved through the world. We call the wheel artificial because it was made by humans. But the human who imagined it was not artificial. The brain that produced the thought was not artificial. The need to move, carry, build, survive, and improve was not artificial. So again: where did the artificial part enter? Maybe we say "artificial" because it separates what existed before humans from what humans transformed. That is fine for communication. A tree and a wooden table are not the same thing. Designed things, synthetic things, industrial things, and harmful things can still be meaningfully different from a tree in a forest. But also, humans never really make anything from nothing. We transform what is already here. We take energy, matter, language, memory, need, and imagination, and we rearrange them. It is never fully made from nowhere. It is transformed. So I am not trying to erase all distinctions by calling everything natural. Natural does not mean harmless. Natural does not mean good. Natural does not mean morally excused. I am only saying that human-made things are not outside nature just because humans made them. Poop and thoughts are the same, in one simple way I know this is a strange example. Sometimes I have this itch to say the first thought that comes into my head. Unfortunately, this was the first thought. But maybe that is why it works. It is funny because it is too human. Also, it makes the point clearly. Why isn't poop artificial? Poop is a product of a human being. It comes from the body. It is produced by biology. We do not call it artificial, even though it is made by a human in the most literal way. A thought is also a product of a human being. It comes from the brain. It is produced by biology too. Poop and thoughts are the same in one simple way: both are products of a human. We treat one as biology. We treat the other as invention. But why? Why does one product of the human body feel natural, while another product of the human body becomes artificial the moment it turns into a tool? A thought does not stop being natural just because it becomes useful. A thought does not become unnatural just because it becomes a wheel, a house, a car, a computer, or a machine that can respond to language. It is still a product of the same earth. The same biology. The same human need to survive, organize, create, and understand. We don't call a beehive artificial Think about ants building a colony. They create a structure that is safer and more efficient for them. They organize themselves. They transform the environment around them. They make something that was not there before. But we do not look at an ant colony and say, "This is artificial." Same with bees making a hive. A beehive is built. It has structure. It has purpose. It stores food. It protects the colony. It is a product of collective behavior. But we call it natural

Probably late to the party, but Claude Code seems to make a separate API call just to generate the auto-suggest hints in its input box.

I was poking around the HTTP traffic between Claude Code and Anthropic with a local proxy I built, and noticed those “Try: fix lint errors” style suggestions aren’t just frontend UI. Each one appears to be its own POST to api.anthropic.com/v1/messages, with a separate system prompt, its own message history, and a separate roundtrip. The system prompt literally starts with [SUGGESTION MODE: Suggest what the user might naturally type next into Claude Code.] The request used the same model I had selected for the main agent. In this case, that was claude-opus-4-7, with 50,484 input tokens and 12 output tokens for one hint. I’m on the Pro flat-rate plan, so I’m not billed per request, but priced like the public API this would be roughly $0.08 per suggestion. Probably obvious to people who have already inspected this stuff, but it made me realize how much “magic UI behavior” in cloud-hosted agents is just extra model calls happening behind the scenes that you never see unless you intercept the traffic. Happy to be told I’m misreading something. submitted by /u/AdStill5266 [link] [comments]

Vibecoding a muon detector

I just the finished proof of concept breadboard phase for a desk object I'm working on that uses a muon detector for a cosmic oracle/magic 8-ball experience and I thought I'd take a step back and write some thoughts on how I've been using Claude Code for preparation and execution so far. I would love to hear people's thoughts on this kind of thing, especially if anyone has workflow recommendations for designing hardware with CC submitted by /u/Mescallan [link] [comments]

ig nobody is talking about the real reason most AI agents fail in the real world

we spend a lot of time in this community talking about capabilities. context windows, reasoning benchmarks, multi-step tool use, how well a model can write code or pass a bar exam. i'm not dismissing any of that. capabilities matter. but when i look at AI products failing in production, the capability of the model is almost never the issue. ive been building and consulting on AI agents for about 18 months. the failure modes i see constantly are: users do not go where the agent lives. the agent has a beautiful web interface. the user visits it twice and stops. not because the agent was unhelpful. because opening a browser tab is a cognitive action that requires intention, and most of daily life does not create the right moment for that intention. humans do not change their behavior to accommodate useful tools. useful tools have to show up in the behavior humans already have. the agent is reactive when it needs to be proactive. the smartest human assistant you have ever had did not just answer questions. they showed up. they flagged things before you asked. they sent you the thing you did not know you needed. most AI agents are search bars with a personality. they wait. waiting is not intelligence in practice. intelligence in practice is noticing and acting. the agent has no memory of who you are. you tell it your preferences, your context, your situation, and then come back 3 days later and it knows nothing. this is not a model limitation. the model can remember if you feed it the right context. this is an architecture choice that most teams make wrong because they are thinking about sessions instead of relationships. the agents that are succeeding in production are not necessarily the ones with the best models. they are the ones that live in whatsapp and imessage and telegram where users already are. that proactively reach out when something relevant happens. that maintain coherent memory of the person across weeks and months of conversation. the tooling to build this way exists now. agno and langchain for orchestration, photon codes for the cross channel messaging surface, langfuse for traces and memory debugging, good persistence in postgres or supabase. the architecture is not magic. what is still rare is the mindset of treating the channel and the memory as primary constraints rather than afterthoughts. i think the gap between what AI agents can theoretically do and what they actually do for people in their daily lives is almost entirely a distribution and persistence problem, not a capability problem. we are solving for the wrong thing. submitted by /u/bcoz_why_not__ [link] [comments]