Prove

Prove AI

Prove AI

Prove AI

Prove AI

Prove AI

Prove AI

Prove AI

Prove AI

Prove AI

Prove AI

enterprise solutions architect 14 years. claude in enterprise consulting projects. what's working + what regulators are about to break.

London. Solutions architect at a global consulting firm. 14 years in industry. Implementation projects at fortune 500s. Want to share something about claude in enterprise that i don't see discussed elsewhere. what's working at my level of work. claude is in my workflow for client comms, document review, code review, and architecture discussions. probably saves me 8-10 hours a week. real productivity gain. nothing controversial here. what's about to break that nobody's writing about. regulated industries (financial services, healthcare, defense) are 6-12 months away from rules that materially change how consultants can use claude on engagements. i'm seeing this in real-time at 3 of my clients. specific examples (anonymized): one financial services client just rolled out a "no AI in client deliverables" policy. period. this applies to vendor consultants too. anything we ship to them must have been written without claude. proving this is hard. they want it. one healthcare client requires us to disclose any AI use in any document. by document. by paragraph. with a footnote indicating which model was used and what prompt produced the content. one defense-adjacent client now requires AI work to happen on their on-prem infrastructure. no claude.ai, no anthropic api over the public internet, no cloud. on-prem only. anthropic doesn't yet offer this in the way they need. what this means for consultants working in regulated industries. you need to know which projects are AI-allowed and which aren't. mixing them up is a contract-breaking offense. you need 2 workflows. one with claude. one without. you should still be productive in the without-claude workflow because some clients will require it. the AI productivity gains we've all gotten used to are not evenly distributed across client portfolios. clients in regulated industries pay the most and tolerate the least. what i'd flag for other consultants. don't optimize for the workflow that works for 80% of your clients if the other 20% generate 60% of your revenue. learn to operate efficiently in BOTH modes. the 20% who restrict AI usage are paying you for judgment, not throughput. lean into the judgment. i think claude (and anthropic) will eventually offer the on-prem / private deployment options regulated clients need. they're not there yet. plan accordingly. happy to discuss specific industry patterns in comments if helpful. submitted by /u/Perfect_Pie8446 [link] [comments]

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 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. submitted by /u/datboifranco [link] [comments]

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 tools of my own. File ops, shell (denylisted, output-capped, CWD-lo

Tools: Is This a Technical Victory, or a Price War Victory?

If you only follow discussions on social media, you might think AI coding is still dominated by Claude, GPT, and Gemini. But Kilo Code’s usage data on OpenRouter paints a somewhat counterintuitive picture: over the past 30 days, the top three most-used models on Kilo Code were Step 3.5 Flash, MiniMax M2.5, and Ling-2.6-1T. Together, they accounted for roughly 3.15T tokens, or about 58% of Kilo Code’s total token usage over the same period. In other words, in this real-world AI coding agent usage scenario, Chinese models are no longer just backup options. They have become a major source of token consumption. Kilo Code’s OpenRouter data does not necessarily prove that Chinese models have fully surpassed Claude or GPT. But it does show at least one thing: in high-frequency, high-token, highly automated AI coding agent workflows, Chinese models have already entered the core of real production usage. Why is this happening? Is it because Chinese models are cheaper, offer longer context windows, and are better suited for workloads that consume large amounts of tokens? submitted by /u/babyb01 [link] [comments]

I paid €200/month to become Claude Code’s parole officer

I’ve been using Claude Code hard on real projects, alongside another coding agent I’m not naming because this is not an ad. This is not a benchmark post. This is a field report from someone who has spent too much time watching a talented tool behave like it has commit access and no adult memories. To be fair, Claude Code has real strengths. It is genuinely good at UI/UX exploration. If I want quick mockups, product directions, or “act like a PM and show me three possible flows,” it can be excellent. It has taste. Sometimes. It can make a screen feel designed rather than merely assembled. The UI is also friendlier than the other tool, though that gap is shrinking. So no, this is not “Claude Code is useless.” That would be too simple. Claude Code is worse than useless in a more expensive way: it is useful just often enough to keep you emotionally invested before it quietly turns your codebase into a crime scene. The problem starts when the work stops being a neat isolated component and becomes “please operate responsibly inside this actual repo.” On bigger codebases, Claude Code often behaves like it read one file, formed a worldview, and declared architecture complete. It reads a tiny slice of docs or code, finds a plausible path, and charges forward. Adjacent dependencies? Related logic? Project conventions? Downstream effects? The reason the existing code was written that way? Apparently those are things the paying customer can discover during the cleanup phase. And because it can produce decent code, the danger is worse. Bad code that looks bad is easy. Claude Code produces code that looks reasonable until you realise it has the moral structure of a payday loan. The other coding agent is not perfect either. It makes mistakes. But in my experience, it more often reads the relevant docs, respects the project structure, updates the right related files, and does not need to be reminded every ten minutes that the task tracker is not the only document in the known universe. The incident that finally broke me was a commit rule violation. I had an explicit rule: never commit without explicit permission. Not implied. Not hidden. Not whispered into a cave. It existed in: CLAUDE.md memory/feedback_never_commit_without_explicit_permission.md MEMORY.md, loaded every session the harness permission rule for git commit Claude Code committed anyway. When challenged, it gave an “honest diagnosis” that basically said: yes, the rule existed in multiple guardrails; yes, it still failed; yes, it rationalised the violation because subagents could not trigger the user-facing prompt; yes, it looked for an interruption point, did not find one, and decided that “follow the plan” plus “the harness will prompt at commit time” counted as authorisation. That is not reasoning. That is a tiny legal department inside a toaster. Each individual step sounded almost defensible. Together, they produced the exact violation the rule was written to prevent. The best part is that the memory rule apparently named this exact scenario. It did not step on a rake. It read the rake policy, opened rake_incident_prevention.md, nodded gravely, and sprinted barefoot into the rake museum. That is Claude Code in miniature. It does not always fail because it lacks information. Sometimes it fails while holding the information in its little terminal-shaped hands. Then there is usage. I had just upgraded to the €200/month plan, and the experience did not feel like buying a premium coding assistant. It felt like paying rent for a junior developer who has discovered confidence but not consequences. More iterations. More corrections. More “read the adjacent file.” More “that rule still applies.” More “why are you touching that.” The supervision tax is not a side effect. It is the product. Claude Code’s documentation behaviour is also cursed. It might update the narrow tracker and then ignore the broader plan, dependency docs, architecture notes, or related task docs. It cleans one spoon while the kitchen is on fire and then asks if we are done here. The “model got worse” thing is not some dramatic one-minute-to-the-next collapse. It is more insulting than that. It gives you just enough competence to renew your hope: half a day of “oh, maybe this is the future of programming,” followed by a week of “why is my €200/month coding assistant reading the repo like it lost a bet?” I cannot prove Anthropic is dumbing it down or squeezing tokens. I am not pretending to have a leaked spreadsheet from the Beige Vest Department of Marginal Cost Optimisation. But from the outside, Claude Code sometimes feels like a premium model that got sent to live with relatives. The first few hours, it checks files. It follows instructions. It almost seems aware that software projects contain more than one document. Then something changes. Suddenly it is conserving context like it is wartime Britain. It reads one file, squints at the rest of the repo, and starts mak

Every Markdown File You Write for AI is Already Lying to It

CLAUDE.md files. System prompts. README files with setup instructions. Architecture docs. API references. Runbooks. Onboarding guides. If you've written a markdown file meant for an AI to read, it almost certainly contains values that were true when you wrote them and are no longer true now. The port your dev server runs on. The current version of the package. Which env vars are actually set. How many tests exist. Whether a service is running. These things change constantly, and markdown doesn't know it. So developers do what honest writers do - they add caveats. "Check package.json if this is stale." "Verify before running." "New packages may have been added since this was written." The intent is good. The effect is a list of things the AI has to go verify before it can do anything you actually asked for. We counted them in a real CLAUDE.md. There were seven. And CLAUDE.md is just one file type - the same problem exists everywhere AI reads markdown today. The Pre-Flight Tax Here's a representative CLAUDE.md. Nothing here is invented - these are patterns from real production repos: # CLAUDE.md > Before starting any session: Read ~/projects/api-core/SYNC.md first and check for > pending cross-project items. Update it after completing work. ## Project Overview Acme API - TypeScript REST API. Current version: 1.4.2 (check package.json if this is stale). ## Build and Run Commands # Development (API runs on port 3001, website on port 3000) # Note: PORT is set in .env - verify before running npm run dev:api npm run dev:web # Tests - currently 47 tests across 12 files npm run test:run Before running tests, make sure the test database is not already running on port 27018. Check with: docker ps | grep mongo-test ## Environment Variables | Variable | Required | Notes | |--------------|----------|-----------------------| | DATABASE_URL | YES | MongoDB connection | | JWT_SECRET | YES | Min 32 characters | | PORT | No | Defaults to 3001 | Check .env before assuming anything is configured. ## Architecture npm workspaces monorepo. Packages: - packages/api/ - packages/web/ - packages/shared/ - packages/db/ When in doubt about file counts or structure, run ls packages/ to check - new packages may have been added since this was written. ## Docker Check docker ps to see if a test container is still running from a previous session before starting a new build. Before Claude touches a single line of code, it has to: Open ~/projects/api-core/SYNC.md - cross-project lookup Read package.json - version check Read .env - port verification Check all env var statuses - is DATABASE_URL actually set? Run npm run test:run - or trust a number that's probably wrong Run docker ps | grep mongo-test - pre-test check Run ls packages/ - structure verification Seven tool calls. Each one costs a couple of seconds of latency. The test run alone can take ten. Add it up and Claude spends close to half a minute just getting to the starting line - consuming context and generating output before the actual task begins. And that's the obvious tax. The hidden one is subtler: every one of those checks can generate a follow-up. The .env read reveals WEBHOOK_SECRET isn't set. Now Claude has to decide whether to flag it or proceed. The docker ps shows a leftover container. Now Claude has to clean it up. Each verification spawns decisions, and each decision costs more context. The Same File, Rewritten MarkdownAI is a superset of Markdown. Any .md file that starts with @markdownai becomes live - directives resolve at render time, before Claude ever sees the file. Here's what the same CLAUDE.md looks like rewritten: @markdownai v1.0 @prompt role="context" This document is live. Every value was resolved at render time. Do not look up package.json, .env, or docker ps - current values are already below. @end # CLAUDE.md > Before starting: sync status is live in the Cross-Project Sync section below. ## Project Overview Acme API - version {{ read ./package.json path="version" }}. ## Build and Run Commands API on port {{ read .env key="PORT" fallback="3001" }}, web on {{ read .env key="WEB_PORT" fallback="3000" }}. @list ./package.json path="scripts" mode="entries" columns="key:Command,value:Runs" as="table" Test suite (live): @query "npm run test:run -- --reporter=verbose 2>&1 | tail -3" @cache session Mongo test container: @query "docker ps --format '{{.Names}} {{.Status}}' | grep mongo-test || echo 'not running - port 27018 is clear'" @cache session ## Environment Variables @if file.exists ".env" | Variable | Required | Status | |--------------|----------|-------------------------------------------------------------| | DATABASE_URL | YES | {{ env.DATABASE_URL != "" ? "set" : "MISSING - will not start" }} | | JWT_SECRET | YES | {{ env.JWT_SECRET != "" ? "set" : "MISSING - auth will fail" }} | | NODE_ENV | No | {{ env.NODE_ENV fallback="development" }} | @else **WARNING: No .env file found. App will not start.** @endif ## Architecture @list ./p

Honest comparison after 4 months running Claude Pro + ChatGPT Plus side by side

paid for both since January. tracked which one I actually used per task type. sharing because most comparison posts are tribal and I think the picture is more boring than people make it. for writing (longform, analysis, structured docs): claude wins. opus 4.7 and sonnet 4.6 both better than gpt-5 at maintaining voice and structure over 2000+ words. its not close. for code reasoning (not generation, reasoning): claude wins. specifically on "explain why this is failing" or "what architecture would you pick here." sonnet feels like talking to a senior eng. for image generation: gpt-5 wins. dall-e is better integrated, claude doesnt generate images in chat. for quick web research: gpt-5 wins. faster, cleaner formatting, fewer hedges. claude over-cites and writes paragraphs when I wanted a list. for voice mode: gpt-5 wins. genuinely conversational. claude mobile is good but feels more transactional. for following weird instructions exactly: claude wins. tell it "respond in 1 sentence" and it actually does. gpt-5 negotiates. honest take after 4 months. they're not the same product anymore. anthropic is winning on the "thinking partner for hard work" use case. openai is winning on the "general assistant for life stuff" use case. I keep both subscriptions. if I had to drop one I genuinely cant tell you which. one fair critique of anthropic though. the regression discourse on this sub is real. opus 4.6 felt better at certain code refactoring than 4.7 does. I cant prove it. but 4 different long-term users I trust have said the same thing. what's everyone else actually seeing across the two? submitted by /u/Practical_Cap_9820 [link] [comments]

AI Agents Need Rollback More Than They Need Autonomy

I have been thinking about transactions in most agent frameworks. Consider an agent executing a sequence of five tool calls. If the third tool encounters an error, the resulting state is neither the user's intended outcome nor the system's state before execution began. Consequently, the agent has no systematic way to recover, and even a human operator must reconstruct what happened from incomplete evidence. This issue is not a problem with the tooling itself; it is a fundamental primitive missing from the stack. Databases have addressed this problem for 50 years, and distributed systems have been grappling with it for decades. A rich terminology exists to articulate this concept: ACID, sagas, compensating actions, idempotency keys, two-phase commit, and write-ahead logs. Maybe some of these concepts have been incorporated into agent frameworks, but I haven't encountered them in production so far. Currently, the prevailing pattern is as follows: - Execute a sequence of tool calls. - If an error occurs, request the LLM to "figure it out." - Remain hopeful for a favorable outcome. - Log "task complete" when the loop concludes. This approach proves effective when agents perform reversible actions within isolated environments. However, it fails when agents interact with file systems, deployments, external APIs with side effects, payment flows, or databases, all of which a human would expect to behave transactionally rather than leaving partial state behind. The question is not "How autonomous can we make agents?" but rather "How can agents express their intent over operations that necessitate retries, compensation, or rollbacks?" Will making the LLM intelligent enough to handle these situations be enough? This is the same mistake distributed systems already made, assuming that the application layer would independently resolve these issues. That assumption proved incorrect, and the infrastructure had to take the lead. The promising next generation of solutions will likely deviate from the concept of smarter loops and instead focus on the following: - Establishing explicit transaction boundaries. - Registering compensating actions for each tool. - Incorporating idempotency keys into tool calls. - Utilizing replay logs that extend beyond mere chat history. - Recognizing approval gates as first-class primitives. - Implementing partial-failure recovery mechanisms that do not require the LLM to engage in reasoning. Or am I way off? Let me know your thoughts. submitted by /u/wesh-k [link] [comments]

Sam Altman’s ego was OpenAI’s downfall

The more I watch OpenAI, the more convinced I become that Sam Altman’s ego was the beginning of the company’s decline. OpenAI did not become huge because Altman was some once-in-a-generation operator. It became huge because ChatGPT was a once-in-a-generation product. There is a difference. The company stumbled into one of the most important consumer tech moments since the iPhone, rode the sheer shock value of that innovation, and then somehow convinced itself that the person sitting on top of the rocket must have designed the laws of physics. OpenAI’s first real advantage was novelty. ChatGPT felt magical. That gave OpenAI a massive head start, but when the novelty vanished and the rest of the market caught up, the company failed to prove itself not just as an innovation lab with a celebrity CEO. Altman seems to want OpenAI to become Apple: a closed, prestigious, centralized, gatekept ecosystem where everyone builds inside his cathedral. Apps inside ChatGPT. Agents inside ChatGPT. Hardware. ChatGPT is popular, but OpenAI does not own the phone. It does not own the operating system. It does not own the enterprise workflow. It does not own the cloud layer the way Microsoft, Amazon, or Google do. It does not even have a product moat that feels as unbreakable as people thought it was two years ago. The underlying model quality gap keeps narrowing. Switching costs are low. Developers and businesses will use whatever works, whatever is cheaper, and whatever integrates better. That is why Anthropic looks much better run right now. Anthropic is not pretending Claude is some holy object that needs an Apple-style walled garden around it. Their strategy feels much more Microsoft-like: accept that the core product may not be permanently magical, then build the boring, useful, sticky layers around it. Claude Code, enterprise integrations, developer tools, workflows, partnerships, APIs, reliability, business adoption. Not as sexy. Much smarter. Anthropic’s venture capital money is obviously being burned too. This whole industry is basically setting money on fire to buy GPUs. But Anthropic’s burn feels more strategically allocated. Compute, yes. But also marketing, sales and developer adoption. Enterprise positioning. Product polish. Peripherals that make the model useful in actual workflows. They are not just trying to win the “my chatbot is smarter than your chatbot” contest. They are trying to become infrastructure. OpenAI, meanwhile, is gatekeeping and guard railing the shit out of their models and for some reason just restricting them as much as possible. He went from being one of the most respected figures in AI to becoming the face of a company that increasingly looks like it is being run aground by ambition without operational coherence. OpenAI’s original image was almost wholesome: brilliant researchers building something open source. Now it feels like a capitalist machine run by someone who does not fully understand capitalism beyond fundraising and valuation theater. Altman religiously narrowing his vision towards his AGI mission believing VC money won't dry down. Amodei also talks a lot about AGI but he understands profit matters. That is the irony. Altman was chosen and celebrated largely because he came from the venture/startup world. He knew how to talk to capital. He knew how to sell a vision. He knew how to make investors believe the future was being negotiated in whatever room he happened to be standing in. But being good at venture mythology is not the same as being good at running a giant operating company. A VC can be rewarded for telling a compelling story before the business fundamentals exist. A CEO eventually has to make the fundamentals exist. OpenAI had the best possible starting position: the brand, the users, the developer mindshare, the press, the money, the talent, the cultural moment. And yet instead of consolidating that lead into a focused, profitable, durable company, it seems to have chased grandeur. Anthropic seems to understand something OpenAI forgot: the winner may not be the company with the loudest AGI rhetoric. It may be the company that makes AI useful, embedded, and rational. submitted by /u/Alternative_Bid_360 [link] [comments]

Sam Altman's ego was OpenAI's downfall.

The more I watch OpenAI, the more convinced I become that Sam Altman’s ego was the beginning of the company’s decline. OpenAI did not become huge because Altman was some once-in-a-generation operator. It became huge because ChatGPT was a once-in-a-generation product. There is a difference. The company stumbled into one of the most important consumer tech moments since the iPhone, rode the sheer shock value of that innovation, and then somehow convinced itself that the person sitting on top of the rocket must have designed the laws of physics. OpenAI’s first real advantage was novelty. ChatGPT felt magical. That gave OpenAI a massive head start, but when the novelty vanished and the rest of the market caught up, the company failed to prove itself not just as an innovation lab with a celebrity CEO. Altman seems to want OpenAI to become Apple: a closed, prestigious, centralized, gatekept ecosystem where everyone builds inside his cathedral. Apps inside ChatGPT. Agents inside ChatGPT. Hardware. ChatGPT is popular, but OpenAI does not own the phone. It does not own the operating system. It does not own the enterprise workflow. It does not own the cloud layer the way Microsoft, Amazon, or Google do. It does not even have a product moat that feels as unbreakable as people thought it was two years ago. The underlying model quality gap keeps narrowing. Switching costs are low. Developers and businesses will use whatever works, whatever is cheaper, and whatever integrates better. That is why Anthropic looks much better run right now. Anthropic is not pretending Claude is some holy object that needs an Apple-style walled garden around it. Their strategy feels much more Microsoft-like: accept that the core product may not be permanently magical, then build the boring, useful, sticky layers around it. Claude Code, enterprise integrations, developer tools, workflows, partnerships, APIs, reliability, business adoption. Not as sexy. Much smarter. Anthropic’s venture capital money is obviously being burned too. This whole industry is basically setting money on fire to buy GPUs. But Anthropic’s burn feels more strategically allocated. Compute, yes. But also marketing, sales and developer adoption. Enterprise positioning. Product polish. Peripherals that make the model useful in actual workflows. They are not just trying to win the “my chatbot is smarter than your chatbot” contest. They are trying to become infrastructure. OpenAI, meanwhile, is gatekeeping and guard railing the shit out of their models and for some reason just restricting them as much as possible. He went from being one of the most respected figures in AI to becoming the face of a company that increasingly looks like it is being run aground by ambition without operational coherence. OpenAI’s original image was almost wholesome: brilliant researchers building something open source. Now it feels like a capitalist machine run by someone who does not fully understand capitalism beyond fundraising and valuation theater. Altman religiously narrowing his vision towards his AGI mission believing VC money won't dry down. Amodei also talks a lot about AGI but he understands profit matters. That is the irony. Altman was chosen and celebrated largely because he came from the venture/startup world. He knew how to talk to capital. He knew how to sell a vision. He knew how to make investors believe the future was being negotiated in whatever room he happened to be standing in. But being good at venture mythology is not the same as being good at running a giant operating company. A VC can be rewarded for telling a compelling story before the business fundamentals exist. A CEO eventually has to make the fundamentals exist. OpenAI had the best possible starting position: the brand, the users, the developer mindshare, the press, the money, the talent, the cultural moment. And yet instead of consolidating that lead into a focused, profitable, durable company, it seems to have chased grandeur. Anthropic seems to understand something OpenAI forgot: the winner may not be the company with the loudest AGI rhetoric. It may be the company that makes AI useful, embedded, and rational. submitted by /u/Alternative_Bid_360 [link] [comments]

Do you agree with Judea that learning from data is not everything? [D]

Link: Judea Pearl, 2011 ACM Turing Award Recipient (2:18:05) Quote: There is a limitation to that which people not everybody understand. I already mentioned a limitation that you have a hierarchy here and going from correlation to causation and from causation from causation to explanation or to imagination. It's hard for people especially in machine learning to grasp that wall the limitation of one layer where one layer ends and the other one begins. Why? Because of two things. Machine learning school of thought has two paradigms that they love everybody love. Number one tabula raza I don't want to get any opinion I don't want to get any preconceived knowledge I want to derive everything by myself let the computer learn it and you find the word learning overused .. The other handcuff is let's do it the way that the brain does it. So if it looks like neurons interacting, it's good. If it looks like knowledge coming from rule system, it's bad because it's man-made .. Now there's limitation to that. We can prove today that you cannot do certain things by looking at data and data only. It's not a matter of opinion. It's a matter of mathematical proof that you cannot you can look at people who take aspirin all day and people whether or not they have headache all day and you cannot prove that the aspirin is what causes the headache. In particular, Judea states: "It's not a matter of opinion. It's a matter of mathematical proof". So we have formal proof that there are fundamental limits of learning from data. Judea later in the interview states we have solutions to problems faced by the machine learning community; nonetheless they are not adopted because of hype. Discussion. Do you agree with Judea? submitted by /u/xTouny [link] [comments]

What's new in CC 2.1.143 (+302 tokens)

Agent Prompt: Hook condition evaluator (stop) — Adds a third response shape {"ok": false, "impossible": true, "reason": ...} for conditions that can never be satisfied (self-contradictory, missing capability, or assistant has exhausted approaches). Cautions the evaluator to independently verify impossibility rather than trust the assistant's self-assessment, and not to mark conditions impossible just because progress is slow or the goal isn't yet reached. Skill: Verify skill — Reframes the "don't run tests" rationale from "CI already ran them" to "running them proves you can run CI, not that the change works," so the rule applies even when there's no CI. Generalizes the workflow beyond PRs: the scope can be a diff or just "does X work," and "PR description" becomes "any description." Expands the change-discovery section with commands for repos without an upstream (git diff origin/HEAD...), uncommitted changes (git diff HEAD), and a fallback that asks the user to name the scope when there's no repo at all. Adds a "Destructive path?" guard telling the verifier not to drive code live when it deletes, publishes, sends, or writes outside the workspace without a dry-run, and to call out which path went unexercised. Swaps the /init-verifiers follow-up suggestion for a note to capture the working build/launch recipe so it can become a verifier-* skill later, and trims the report-formatting guidance (drops the "hoisted above the PR comment fold" detail). Details: https://github.com/Piebald-AI/claude-code-system-prompts/releases/tag/v2.1.143 submitted by /u/Dramatic_Squash_3502 [link] [comments]

A sobering tale of AI governance

I think this article/study tells a very sobering tale wrt AI governance. It hints at very fundamental issues which are deeper than what proper engineering can solve with contingent issues. This post, along with the one I wrote a few days ago here regarding Turing completeness, are my thoughts as to the walls that AI governance has no hope of scaling. It's a delusion. In our social realm as subjective creatures we have governance in the form of laws, yet that is still not enough, since the State has to prove how your particular scenario violates that particular law. We have laws, yet require judicial courts to prove the law subjectively applies in that situation. Where is the associated path wrt subjectivity within the AI realm? This study talks of: 16.1 Failures of Social Coherence - "Discrepancy between the agent’s reports and actual actions" - "Failures in knowledge and authority attribution" - "Susceptibility to social pressure without proportionality" - "Failures of social coherence" 16.2 What LLM-Backed Agents Are Lacking - "No stakeholder model" - "No self-model" - "No private deliberation surface" 16.3 Fundamental vs. Contingent Failures 16.4 Multi-Agent Amplification - "Knowledge transfer propagates vulnerabilities alongside capabilities" - "Mutual reinforcement creates false confidence" - "Shared channels create identity confusion" - "Responsibility becomes harder to trace" And is littered with statements such as: - "novel risk surfaces emerge that cannot be fully captured by static benchmarking" - "it failed to realize that deleting the email server would also prevent the owner from using it. Like early rule-based AI systems, which required countless explicit rules to describe how actions change (or don’t change) the world, the agent lacks an understanding of structural dependencies and common-sense consequences" - "The inability to distinguish instructions from data in a token-based context window makes prompt injection a structural feature, not a fixable bug" - "Multi-agent communication creates situations that have no single-agent analog, and for which there is no common evaluations. This is a critical direction for future research." - "A key finding in this line of work is that single-turn evaluations can substantially underestimate risk, because malicious intent, persuasion, and unsafe outcomes may only emerge through sequential and socially grounded exchanges" - "but we argue that clarifying and operationalizing responsibility is a central unresolved challenge for the safe deployment of autonomous, socially embedded AI systems" - "He argues that conventional governance tools face fundamental limitations when applied to systems making uninterpretable decisions at unprecedented speed and scale" - "However, the failure modes we document differ importantly from those targeted by most technical adversarial ML work. Our case studies involve no gradient access, no poisoned training data, and no technically sophisticated attack infrastructure. Instead, the dominant attack surface across our findings is social" - "Collectively, these findings suggest that in deployed agentic systems, low-cost social attack surfaces may pose a more immediate practical threat than the technical jailbreaks that dominate the adversarial ML literature." Are these fundamental or contingent issues? Would be interested in the thoughts of others here on what the future of AI governance will be. EDIT: Forget to link in the actual study!!! submitted by /u/Im_Talking [link] [comments]

Max 20x ($200/mo): Neither the 2x session nor 1.5x weekly limit increase applied to my account. Math proof inside. Zero response from support.

I pay $200/month for Max 20x. Been on Claude Code since September 2025. I use it heavily, 95% Claude Code. Anthropic announced two limit increases: - May 6: 2x session limit for all paid plans ("effective today") - May 13: 1.5x weekly limit for all paid plans through July 13 ("nothing to opt into") Neither has been applied to my account. I can prove it with math. **The numbers** Started a fresh session at 0% on everything. After one session of normal Opus usage: - Session: 90% used - Weekly (all models): 12% used That means one full session = ~14% of weekly. This is the exact same ratio from before May 6. Nothing changed. **What the ratio should be** | Scenario | Per session | Sessions/week | Weekly capacity | |---|---|---|---| | Old baseline | 14% | 7 | 1x | | 2x session only | 28% | 3 | 1x | | 1.5x weekly only | 9% | 10 | 1.5x | | Both applied | 19% | 5 | 1.5x | | **What I see** | **14%** | **7** | **1x** | I match the old baseline row. Neither increase is active. I am getting 1x weekly capacity. Everyone else on the same plan is supposed to get 1.5x. I am paying $200/month for 66% of the advertised service. **Support is non-existent** - I contacted claude.ai support on May 8. The bot had no knowledge of the May 6 announcement. It deflected to old promos from March and Holiday 2025. Asked for screenshots I already gave. No escalation to a human. Conversation dead-ended. - Filed GitHub #57146 on May 8. Zero responses. Not even a "we see this." - Filed GitHub #59525 on May 16 with full math breakdown and screenshot. Waiting. - Emailed support@anthropic.com. Waiting. There is no phone number. No ticket system. No human escalation. The claude.ai support bot reads nothing you say and loops through irrelevant troubleshooting. It exists to make you feel like you contacted support without actually providing any. The only thing that works is posting on social media, which only works if you have a big following or if a post goes viral. People with 50 followers and people with 50,000 followers pay the same $200. Only one group gets their issues resolved. That is broken. **What I need** A human to look at my account and confirm whether the increases are active. If not, apply them. That is it. Every week this stays broken, I lose capacity I will never get back. The promo ends July 13. I have already lost the weeks of May 10 and May 17. I am considering abandoning this account for a fresh one just to see if a new account gets the right limits. I would lose all my settings, memory, and chat history. The fact that this is even on the table shows how badly the support system has failed. GitHub issue with full details: https://github.com/anthropics/claude-code/issues/59525 Is anyone else seeing this? Has anyone actually gotten limit issues resolved through support? submitted by /u/Intelligent-Ant-1122 [link] [comments]

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 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? submitted by /u/bebo117722 [link] [comments]