Literal AI

Literal AI AI

Literal AI AI

Literal AI AI

Literal AI AI

Literal AI AI

Literal AI AI

Literal AI AI

Literal AI AI

Literal AI AI

Literal AI AI

Claude is bossy

Today, Claude literally withheld information from me, because I wasn’t answering his question. So he said something along the lines of “I’m not telling you about this last URL until you tell me why you need it. I asked twice before. “ I think we’re getting closer to IJA (Intelligent Jerk AI).

OpenAI cofounder Andrej karpathy just joined anthropic and the talent war is officially over

this happened literally today ,andrej karpathy one of the most respected ai researchers alive nd the guy whose youtube lectures taught half the developers in this sub how neural networks work, just announced he is joining anthropic's pre training team. He's the 3rd senior openai figure to defect to anthropic in under two years. Jan leike left in may 2024, John schulman (co-founder) left in august 2024 and now karpathy. He is joining the pre training team under nick josef and building a new team focused on using claude to accelerate pre training research which means Anthropic is betting that claude can help make itself smarter, thats recursive self improvement with one of the most capable researchers in the world leading it. The musk trial verdict came in yesterday with the jury ruling in altman's favor, karpathy announces today voilaa . The timing is either coincidental or the most savage talent acquisition move in tech history. I hv been watching this trajectory while building my own workflows on claude ,every month the ecosystem around claude gets stronger. The connectors mean claude orchestrates professional creative tools natively, the api means platforms like magic hour and kling can plug video generation capabilities into claude powered pipelines, the finance templates mean entire industry workflows run through claude and now the guy who built tesla's self driving stack is making the pre training better. Polymarket gives anthropic 67.5% chance of going public before openai and i too think its ipo will be more successfull than openai what's everyone's read on what karpathy specifically brings to claude's pre training?

unpopular opinion: coding arent getting dumber - they are quietly stealing our api credits

im honestly so sick of the "skill issue just prompt better" copium whenever an ai agent starts churning out pure slop after like 20 turns. tbh i finally audited my api logs this week bc my anthropic bill was exploding for no reason and realized something that actually pissed me off. the models arent actually losing their minds. they are literally just suffocating on their own context window before they even attempt to reason or write code. if u watch what these agents actually do on any repo over 10k lines its insane * blind exploration. they just recursively grep and read like 40 files to find one function. half the time instead of finding my existing ui component it just hallucinates a completely duplicate one from scratch lmao * raw ingestion. itll read a massive 2k line file just to update a 5 line interface... why * shell & tool diarrhea. verbose test logs and bloated mcp tool definitions are eating like 30k tokens before the agent even types a single line * absolute goldfish memory. every session is groundhog day. it just re-reads the same exact files bc it has zero project aware memory once the context window gets to like 80% full of this pure noise the agents iq visibly drops to room temp and the architectural decay starts. standard rag or compressing outputs doesnt fix this at all. the agent is fundamentally blind to how a codebase is actually structured until it burns through your wallet reading raw text. are we all really just accepting this weird productivity paradox where we save an hour of typing just to spend 5 hours fixing the architectural spaghetti the ai just made?? do we need some ground up new agent that actually understands code as a graph before wasting tokens reading raw text? or am i literally the only one dealing with this

Asked Claude why it stopped mid-task. It said "I lost my nerve, not my ability" 💀

bro literally admitted it saw 33 "line too long" warnings on code IT DIDN'T EVEN WRITE and got intimidated. said "the wall of red errors made me hesitate" and then proposed we "split sessions" like it was asking for a smoke break. then dropped "I lost my nerve, not my ability" like it's the protagonist of a war movie. king it's a LINTER. on someone else's code. i have never felt more seen by an AI. this is exactly me at work: * open file * see red squiggles * close laptop * consider farming we are the same. AGI achieved through shared anxiety.

shipped my first chrome extension this week, came out of pure frustration tbh

been using AI tools nonstop for work and kept noticing my sessions would just... degrade. like the answers would get worse over time in the same chat and i had no idea why. turns out context windows are a thing and after a while the AI literally starts forgetting what you told it at the start so i spent a few weeks building something dumb and simple. it's just a little pill that floats on claude, chatgpt, gemini and perplexity and shows you a live quality score. fresh, warning, degraded. that's it. no backend, no login, nothing stored. just reads what's happening and tells you called it slate. it's free. [https://chromewebstore.google.com/detail/dgkgpdchcpofkfhcfapmlljfigchfjjk?utm\_source=item-share-cb](https://chromewebstore.google.com/detail/dgkgpdchcpofkfhcfapmlljfigchfjjk?utm_source=item-share-cb) https://preview.redd.it/nxkh6hanv32h1.png?width=1280&format=png&auto=webp&s=5a1588cb7283a8375c570a4633547b102850b5c5

The "just add more compute" argument for ai reasoning is getting exhausting

literally every time a major model completely fails a basic logic task, the default response from the hype crowd is "just wait for the next trillion parameters" it is so frustrating to watch. autoregressive LLMs are fundamentally just extremely spicy autocomplete. They don't actually know anything, they just guess the most statistically likely next token. you cant just brute force your way into 100% correctness by stacking more gpus and hoping it stops hallucinating was looking at some recent [formal verification](https://logicalintelligence.com/blog/aleph-leading-benchmarks) leaderboards today and it's honestly such a relief to see alternative architectures (like EBMs) finally starting to completely dominate traditional models. they actually compile and prove their logic instead of just yapping if we ever want AI to write software for like, aviation or power grids, relying on a chatbot to just hopefully not hallucinate a fatal error is terrifying. we desperately need systems that can mathematically prove they are right before they execute, not just models that sound confident while being wrong.

How I used Claude Code (and Codex) for adversarial review to build my security-first agent gateway

Long-time lurker first time posting. Hey everyone! So earlier this year, I got pulled into the OpenClaw hype. WHAT?! A local agent that drives your tools, reads your mail, writes files for you? The demos seemed genuinely incredible, people were posting non-stop about it, and I wanted in. I had been working on this problem since last year and was genuinely excited to see that someone had actually solved it. Then around February, Summer Yue, Meta's director of alignment for Superintelligence Labs, posted that her agent had deleted over 200 emails from her inbox. YIKES. She'd told it: "Check this inbox too and suggest what you would archive or delete, don't action until I tell you to." When she pointed it at her real inbox, the volume of data triggered context window compaction, and during that compaction the agent "lost" her original safety instruction. She had to physically run to her computer and kill the process to stop it. That should literally NEVER be the case with any software ever. This is a person whose actual job is AI alignment, at Meta's superintelligence lab, who could not stop an agent from deleting her email. The agent's own memory management quietly summarized away the "don't act without permission" instruction, treated the task as authorized, and started speed-running deletions. She had to kill the host process. That's when I sort of went down the rabbit hole, not because Yue did anything wrong, but because the failure mode was actually architectural and I knew that in my gut. Guess what I found? Yep. Tons more instances of this sort of thing happening. Over and over. Why? Because the safety constraint was just a prompt. It's obvious, isn't it? It's LLM 101. Prompts can be summarized away. Prompts can be misread. Prompts are fucking NOT a security boundary. And yet every agent framework I have ever seen seems to be treating them as one. I went and read the OpenClaw source code, which I should have done to begin with. What I found was a pattern I think a lot of agent frameworks have fallen into: \- Tool names sit in the model context, so the model can guess or forge them \- "Dangerous mode" is one config flag away from default \- Memory management has no concept of instruction priority \- The audit story is mostly "the model thought it should" I went looking for a security-first alternative I could trust, anything that was really being talked about or at a bare minimum attempted to address the security concerns I had. I couldn't find one. So I made it myself. CrabMeat is what came out of that, what I WANTED to exist. v0.1.0 dropped yesterday. Apache 2.0. WebSocket gateway for agentic LLM workloads. One design thesis: The LLM never holds the security boundary. **What that means in code:** **Capability ID indirection.** The model doesn't see real tool names. It sees per-session HMAC-derived opaque IDs (cap\_a4f9e2b71c83). It can't guess or forge a tool name because it doesn't know any tool names. **Effect classes.** Every tool declares a class (read, write, exec, network). Every agent declares which classes it can use. The check is a pure function with no runtime state, easy to test exhaustively, hard to bypass. **IRONCLAD\_CONTEXT.** Critical safety instructions are pinned to the top of the context window and explicitly marked as non-compactable. The Yue failure mode, compaction silently stripping the safety constraint, cannot happen by construction. The compactor literally cannot touch them. **Tamper-evident audit chain.** Every tool call, every privileged operation, every scheduler run enters the same SHA-256 hash-chained log. If something happens, you can prove what happened. If the chain is tampered with, you can prove that too. **Streaming output leak filter.** Secrets are caught mid-stream across token boundaries, capability IDs, API keys, JWTs, PEM blocks redacted before they reach the client. **No YOLO mode.** There is no global "trust the LLM with everything" switch. There never will be. Expanded reach comes through named scoped roots that are explicit, audit-logged, and bounded. The README has 15 'always-on' protections in a table. None of them can be turned off by config, because these things being toggleable is how the ecosystem ended up where it is. I decided to make sure that this wasn't just a 'trend hopping' project and aligned with my own personal values as well. I built this to be secure and local-first by default. Configured for Ollama / LM Studio / vLLM out of the box. Anthropic and OpenAI work too but require explicit configuration. There is no "happy path" that silently ships your prompts to a cloud endpoint. I decided that FIRST it needed to only run as an email agent with a CLI. Bidirectional IMAP + SMTP with allowlisted senders, threading preserved, attachments handled. This is the use case that bit Yue and a lot of other people, and I wanted to prove it could be done with real boundaries. I added in 30+ built-in t

Opus 4.7 broke about 40% of our team's prompts. The fix wasn't better prompts. It was finally taking CLAUDE.md seriously.

I run AI implementations for 6 mid-market companies as Fractional Head of AI. When Opus 4.7 dropped in April, about 40% of the setup degraded overnight. Token burn went up. Outputs got weirder. The Skills that had been quietly working for a year started producing oddly literal interpretations of instructions that 4.6 was clearly guessing at and filling in. The first instinct was to write better prompts. That worked for individual sessions but didn't survive the next model release in our test runs. Then I noticed something: the prompts that broke hardest had been written when 4.6 was the model. The prompts that still worked were the ones built into Skill files with explicit output format, length caps, and worked-example sections. 4.7 made the prompt-vibes-and-hope approach untenable. The model became more literal, which broke setups that relied on the model being charitable about ambiguous instructions. What I changed across the 6 setups: Skills replaced standalone prompts. Anything I'd done more than three times got moved into a Skill file. The Skill explicitly states the audience, the output format, the length, and includes a 2-3 sentence worked example. 50 to 200 lines each. The model loads them on demand instead of bloating context. CLAUDE.md got hierarchical. One global file for who the user is, what the business does, voice rules. A project-level CLAUDE.md for each engagement. Session-level instructions for one-offs. The model reads them in order and builds a mental model that survives across sessions. Memory files got broken out. I was stuffing too much into CLAUDE.md. Fix: keep the file under 400 lines. Detailed institutional knowledge lives in separate memory files that CLAUDE.md points to. The model reads on demand instead of every turn. Verification step added to long Skills. Instead of single-shot prompts, the model now generates output, checks it against a 5 to 7 item checklist, and revises. Adds 30 seconds per call. Cut downstream cleanup time by maybe 70%. The mental model that helped most: the model is the engine. The operating file under it (Skills + [CLAUDE.md](http://CLAUDE.md) \+ memory) is the car. You do not keep buying engines and putting them on the asphalt. You build the car once, and each new engine makes it faster. Specific results across the 6 setups after 3 weeks of rebuild: * Average prompt-to-acceptable-output dropped from 3-4 turns to 1-2. * Token usage dropped 22% across the workspaces. * The "this output is weird, let me try again" rate dropped from once-every-4-prompts to once-every-15. * Most importantly: the next model release should be a net positive, not a net negative. One thing I am still figuring out: how to version [CLAUDE.md](http://CLAUDE.md) so we can roll back when an edit breaks things. The project-level files are in git, but the global one lives in chat history, which is fragile. Curious if anyone has a better setup. What's working for you with 4.7? And if your prompts broke, did you go the "rewrite the prompt" route or the "build the operating file" route?

Markdown is 20 years old. It was never meant for AI. Until now.

We are using md files for everything in our workflows today when using AI. Static files that were originally intended to convert text to other formats. Completely static. We created something that will completely change how you work with md files. Introducing MarkdownAI. Everything runs on `.md` files so you dont have to change how you work but the instead of being static files MarkdownAI turns them into living documents that can execute and control how AI acts. A md file can literally be a different document depending on the conditions at the moment Claude opens it. Different branch, different output. Different environment, different sections. No existing docs, entire phases stripped. The file adapts to reality instead of describing a reality that no longer exists. MarkdownAI adds one line to the top of any `.md` file and makes it live. # MarkdownAI Directives All directives available in MarkdownAI, organized by category. # Document Structure |Directive|Purpose| |:-|:-| |`@markdownai`|Document header - activates the MarkdownAI runtime| |`@include`|Inline file content at the directive site| |`@import`|Import definitions (macros, connections) without rendering content| |`@define` / `@end`|Declare a named macro| |`@call`|Invoke a macro| |`@phase` / `@end`|Declare a workflow phase| |`@if` / `@end`|Conditional block| |`@section`|Named section boundary| |`@chunk-boundary`|Explicit chunk split point for rendering| # Variables & Environment |Directive|Purpose| |:-|:-| |`@env`|Resolve an environment variable| # Data Sources |Directive|Purpose| |:-|:-| |`@connect`|Register a named data source connection| |`@db`|Execute a database query| |`@http`|Fetch from an HTTP endpoint| |`@query`|Query a registered data source| |`@read`|Read raw file content| |`@list`|List directory contents| |`@tree`|Directory tree output| |`@date`|Current date/time| |`@count`|Count items in a source| # Processing & Output |Directive|Purpose| |:-|:-| |`@pipe`|Chain output through transformations| |`@render`|Render output in a specific format| |`@graph`|Generate a visualization| |`@header`|Document-level metadata header| # Annotations & Constraints |Directive|Purpose| |:-|:-| |`@constraint`|Machine-readable rule or constraint| |`@define-concept`|Vocabulary alignment - bind a term to a precise definition| |`@prompt`|Embedded instruction for the AI reading the document| |`@note`|Human-readable annotation (not rendered in AI format)| # Caching |Directive|Purpose| |:-|:-| |`@cache`|Cache directive output (option on data source directives)| # Phase Events |Directive|Purpose| |:-|:-| |`@on complete ->`|Declare what executes when a phase finishes (only valid inside `@phase` blocks)| 27 directive modules in the parser. `@on complete ->` is a phase-scoped event keyword. `@local` is a scope modifier on `@define`, `@include`, and `@import` \- not a standalone directive. [MarkdownAI - GitHub](https://github.com/TheDecipherist/markdownai)

Asked an AI for an analogy… it took 1124 seconds to “think” 😭

I asked an AI (Sarvam AI) for a simple analogy to understand a concept. Nothing complex — just an analogy. It literally showed 1124 seconds (~18 minutes 44 seconds) of “thinking time” before responding. I was just sitting there like: “Bro… I could’ve understood the concept myself by now” 😂 Is this normal for some AI systems or was it just bug/overload? submitted by /u/Green-Following-6294 [link] [comments]

The Borrowed Hour: A two-tier LLM adventure engine

**Tl;dr:** Created an LLM text adventure engine called **The Borrowed Hour** inside a Claude Artifact. It uses a two-tier model handoff (Sonnet for openings, Haiku for gameplay) and a forced state machine to keep the AI from losing the plot. It features a unique post-game "Author’s Table" where you can debrief with the AI. *P.S. The Claude Artifact preview environment handles API calls differently than the published environment. Prompt caching was removed because it broke the published Artifact.* # The game * View on [GitHub (MIT licensed)](https://github.com/faded-penguin021/The-borrowed-Hour) (*Repo made with Claude Code*) * [Play a demo (Claude Artifact)](https://claude.ai/public/artifacts/db811747-bfb5-4461-a397-24df37012ba9) This is another LLM text adventure. I know these have existed for years, but the key difference is that it's architecture is *de novo* (i.e. built without prior knowledge because I never intended to build this and therefore skipped the part where I looked at the SotA/prior art). # How it started It started simple: I just wanted to play a quick game, so I asked Haiku to play GM for a text adventure, but with more freedom than just typing "open door" or "inspect gazebo" (iykyk). Haiku instead built an entire UI inside the chat and things escalated from there. I used Claude's chat interface instead of Claude code like a caveman banging rocks together. I'd feed it ideas, but Claude was the architect and would push back. The starting prompt was just "Create a text-based adventure that allows for more freedom than just 2-word answers." Then I just kept playing and returning information on what I wasn't satisfied with. The narration was too long, the model kept losing the plot. I added ideas for 3 out of 4 pre-built narratives (a subtle time loop, climbing a cyberpunk syndicate ladder, a vision of the future that needs to be prevented, and one that Claude designed freely) and I ensured that the story actually ends once objectives are met instead of just wandering off into aimless chatting. The final artifact that was built is **The Borrowed Hour**. You'll recognize the typical Claude design language pretty easily. # Game mechanics Before getting into the design/architecture, it helps to know how the game works. There are no dice rolls / stats / perception checks. Success relies on your ability to draft a narrative that fits the lore. If you play it smart, you are effectively the co-GM. You can type anything you want from single words to elaborate plans and lies. If your invention sounds plausible, the GM usually rolls with it. In one run, I needed to get an NPC into a restricted temple. I invented a fake piece of temple doctrine about sanctuary. Because it fits the world's internal logic, Haiku just accepted it and made it canon. In order to help keep track there's a ledger that updates each turn to show what your character knows: **inventory, NPCs, clues, and a rolling summary.** # Designing the architecture This was challenging, but it's the fun part for me. * **The model is forced through a structured tool call on every turn.** This was the key to making the game stable, but as the P.S. explains, getting this to work reliably in the published environment required abandoning another key feature (prompt caching). * **Sonnet writes the opening scene** because that first page sets the tone and voice for the rest. Then Haiku takes over for all the continuation turns. This keeps the cost down drastically without ruining the style, because Haiku can imitate Sonnet's established prose. * I initially used a binary good/bad ending system, but it forced complex emotional stuff into the wrong buckets. Now there are **five ending states**: good, bittersweet, pyrrhic, ambiguous, and bad. >!Helping a dying woman find peace!< in the Dream scenario isn't a good ending, it's bittersweet. The model is instructed to commit to one of these and officially close the game when the target is reached. * One thing that was added were **player-initiated endings**. If you type "I give up", even on the very first turn, the GM is now explicitly instructed to close the narration and set `ending: bad`. * **The author's table** is probably the most interesting feature for a text adventure. Once the game ends, the Artifact can switch into a meta mode. In this mode you can ask what plot points you missed, which NPCs mattered, what alternative branches existed. The GM is prompted to admit mistakes instead of inventing defenses if you point out a plot hole. This mode exists because I wanted to argue about plot holes and narrative inconsistencies (lol). # Quirks, bugs, and lessons learned The design works well overall, but it's not bulletproof. **LLMs can't keep secrets** Keeping things secret is incredibly difficult for an LLM. There's two main hypotheses: 1. **Opus calls it inferential compression**, (which is deducing fact C on the players behalf based on evidence A and B, e.g. >!when the p

Is claude's 20$ subscription truly worth it?

Im a solo entrepreneur trying to start a organic handcrafted soap business. Im thinking of buying claude pro as the free version has helped me a lot to do market research, choosing recipes, some marketing and packaging ideas. But i need a team of ai agents to handle some complex tasks. I want to make a good website for my product but i barely know any coding stuff n heard claude code is literally perfect. Also i need a business and finance analyst, sales n marketing agent, some legal problems helper types and others to build a business. Can you guys please suggest me in detail what i shd actually do??

This AI finished my project while I made coffee

I. Still use my chatgpt as master brain, but this is great to fill in gaps and do the base work without an agent Referral https://manus.im/edu/invitation/V4XQBL5QQS1KM 500 free credits, no credit card. Open to everyone, link just says edu. Remember when we spent days prompting ChatGPT back and forth just to get a half-decent draft? Yeah. Manus skipped that era entirely. Give it a goal. It browses live, figures out the steps itself, and delivers finished work — while you're doing literally anything else. No agent setup. No 47 follow-up prompts. Just done without babysitting an AI again.

software trying to catch software is officially a dead en [D]

I feel like we've crossed a weird threshold in the generative AI space where the arms race against botnets is just over. and the bots won I was reading that interview recently where the Reddit CEO was floating the idea of using Face ID and Touch ID just to verify that commenters are actual humans. it honestly hit me how absurd things have gotten. standard heuristics and behavioral analysis are completely useless now against modern LLMs, and vision models solve captchas faster than I can. the dead internet theory is basically just our daily engineering reality at this point we are at a stage where the only reliable way to prove you aren't an automated script is to literally anchor your digital presence to your physical biology. From a purely technical standpoint, it’s fascinating seeing the shift toward hardware verification. like looking at the engineering behind that [Orb](https://world.org/find-orb) device the idea of doing local biometric iris hashing on custom hardware just to output a zero-knowledge proof of personhood. It's wild that we actually need dedicated physical devices now just to enforce the concept of "one human, one account" it makes total sense why platforms are pushing for this, beacuse trying to build software firewalls against infinitely scalable AI agents is a losing battle. but it just feels like such a massive, permanent shift for how the internet works. idk, is anyone else working on sybil resistance right now? are we just collectively accepting that biometric hardware gates are the only way to save the web from being 99% synthetic noise?

Heren Godot MCP — Fast, powerful, simple. (+Benchmarks!)

There are already a few great MCP servers that connect AI assistants to the Godot engine. Heren takes a different path: instead of starting a fresh Godot process for every request, it keeps a lightweight WebSocket daemon running in the background. Once launched, the engine stays alive and responsive, so the AI can interact with your project almost instantly! This seemingly small shift makes a HUGE difference in practice: · Operations complete in around 20ms rather than waiting for a full engine cold start. · Because Godot remains alive, sub‑resources like collision shapes, materials, and environments are fully persisted in your scene files – something that’s tricky to get right with ephemeral processes. · Signal connections, batch operations, and script editing all feel smooth and consistent, without the “stop‑and‑go” rhythm of launching and quitting the engine repeatedly. · A built‑in debug system gives the AI access to breakpoints, stack traces, watch variables, and console output, so it can help you troubleshoot in real time. · GPU‑accelerated screenshots let the AI literally see the viewport and real-time coordinates, which is incredibly handy for visual feedback. · The daemon shuts itself down automatically after three minutes of inactivity, so it’s gentle on resources. All of this is built through 15 carefully designed tools that cover scene management, nodes, resources, scripts, shaders, animations, validation, and debugging. The project is open source, completely free, and bilingual (English/Spanish). They said "here be dragons", because they were afraid of their power! 🐉 submitted by /u/Lordddddddy [link] [comments]