aifeed.fyi - AI news today

5 June 2026

Ai Top News

Models

Hardware

reddit.com

Did Export Controls Accidentally Create Huawei's Biggest Opportunity Yet?

The most interesting part of Huawei's announcement isn't the claim about future chip performance. It's the fact that Huawei executives are openly saying that export controls helped create the conditions for this push in the first place.

When access to foreign technology became restricted, Chinese companies had two choices: fall behind or invest heavily in domestic alternatives. Huawei is arguing that the second option is exactly what happened. Whether the company ultimately achieves its 2031 goals remains uncertain, but the broader lesson is that pressure can sometimes accelerate the very capabilities it was intended to slow.

--- TOP COMMENTS ---
Yes. Why do you think Jensen has been so adamant about pressuring the White House to open chip sales in China? It’s not just to unlock another market. NVIDIA’s biggest moat and lock-in is their CUDA software. Excluding China means they’ll develop their own competing software, probably cheaper, and they’ll start programming on that standard instead of CUDA.

Not only will they lose China, but they can lose the rest of the world market if China can produce a cheaper product and others start programming for that software instead.

Trump is an idiot.

---

> It's the fact that Huawei executives are openly saying that export controls helped create the conditions for this push in the first place.

There’s literally no downside in ascribing progress to export controls, so I wouldn’t read anything into it at all.

If export controls remain in place, and they are making progress, I guess that’s the same situation. If export controls get lifted, they get more chips, so I doubt that somehow puts them in a *worse* situation.

Export controls can’t have been *that* helpful, because they were still running elaborate schemes to smuggle as many chips as possible through countries like Singapore...

Yesterday

Products

Regulation

Applications

Developer Tools

/r/LocalLLaMA

BeeLlama v0.3.1 – latest llama.cpp with extras! DFlash, MTP, q6_0 cache, TurboQuant. Single RTX 3090: Qwen 3.6 27B & Gemma 4 31B up to 177.8 tps (4.93x over baseline)

20h ago

/r/LLMDevs

Coding agent built as developer-driven workflows — human-in-the-loop, hybrid search, editable context

I've been building a coding agent and just open-sourced it. It's a different bet from terminal agents like Claude Code or Aider: instead of fire-and-forget autonomy, it's a visual, human-in-the-loop workbench where you trigger each workflow and approve every plan, search, and change.

Sharing the architecture because I made a few design calls I'd like to pressure-test — the orchestration is all LangGraph, and I went back and forth on the workflow structure.

**Deloper-driven workflows, not one generalist loop**You choose which workflow runs and when — the agent doesn't improvise end-to-end. Each is its own LangGraph state machine with a configurable round budget and its own tool subset:

* **Plan** — 3-stage: tool-using draft → self-review → final plan you can edit
* **Implement** — investigate (with sandbox verification) → structured draft → self-critique, producing per-file diffs you approve individually
* **Research** — multi-round loop over code search, web search, and docs, then synthesis
* **Build Context** — autonomous agent that reads/searches and assembles an implementation-ready brief
* **Browse/Inspect** — Playwright-driven browser to debug a running app or extract page content

Each runs when you trigger it and stops with output for you to review.

**Hybrid search instead of the model guessing**

Code is chunked with tree-sitter (functions/classes, not arbitrary line splits) and indexed in PostgreSQL — BM25 (ParadeDB) + pgvector ANN fused with reciprocal rank fusion, then reranked by a local cross-encoder. Embeddings and reranking run locally via sentence-transformers, so code never leaves for a hosted indexing service. Incremental re-indexing on SHA-256 change.

The same search is also exposed as an MCP server over SSE (`search_code`, `search_documents`, `build_comprehensive_context`), so Claude Code or any MCP client can consume it. Complementary to terminal agents, not just competing.

**Transparent, editable context**

In most agents, context assembly is invisible — the model decides what to read and you can't inspect it. Here every file, search result, plan, and note is a card you can pin, edit, summarize, or remove before it's fed to the model. A token meter tracks the assembled prompt against a soft cap. You curate exactly what the LLM sees, which matters for both output quality and cost.

**Other bits:** OS-level sandboxed execution (seatbelt/bubblewrap) for verifying generated code before trusting it, pluggable providers with a standard/high tier toggle, real-time streaming with mid-generation cancellation, per-session cost tracking.

Honest tradeoff: if you want to type a goal and walk away, use a terminal agent; this is for when you want to review every plan and change, hand-tune context, and keep retrieval local.

**Stack:** NiceGUI frontend, LangChain/LangGraph orchestration, PostgreSQL (ParadeDB + pgvector), tree-sitter, optional Exa for web search.

Repo: [https://github.com/arsicd/nice\_coding\_agent](https://github.com/arsicd/nice_coding_agent)

Would love feedback on the workflow design especially — I went back and forth on round budgets and the self-critique step, and I'm curious how others have handled the plan→implement handoff.

--- TOP COMMENTS ---
Nice design. The Browse and Inspect piece is the part I would pressure test hardest.

I am building FSB, which gives agents their own Chrome tabs, DOM reads, screenshots, actions, and cleanup so browser work is less like a hidden Playwright loop and more like a real tool surface the agent can report on. It might be useful as a reference point for your inspect workflow: https://github.com/LakshmanTurlapati/FSB

The main lesson from using it in anger: make browser state explicit. Which tab is owned, what changed after an action, what got clicked, what credential surface was touched, and when the tab is closed. That keeps human review practical instead of turning browsing into another black box.

---

Human approval is the right angle. Full autonomy sounds cool until the agent quietly wrecks context...

Yesterday

/r/PromptEngineering

The two changes that improved LLM responses and resulted in quality code

I've been building a fairly complex app this way (real-time video processing, GPU rendering, multiplayer) and I hit the wall everyone hits. It's great for a weekend, then the code just goes to shit because the LLM keeps repeating the same mistakes you've already corrected. Two changes fixed it for me. Sharing in case it saves someone a headache.

**1. A living spec doc as the AI's memory.** Before I touch a feature, I keep an `architecture.md` that records not just *what* the app is, but *why* each decision was made. The "why" is the magic. Every new chat starts from zero memory but the doc *is* the memory. Update it after every feature.

**2. Two AIs that check each other.** I have one model interrogate the idea and write an implementation plan, then I hand that plan to a *different* model and tell it to tear the plan apart. These can be edge cases, contradictions, simpler approaches. They argue until I am satisfied with the results. (I use Gemini + Claude, but any two strong models work.) One AI alone is a confident genius with blind spots. Two catch what one sails past.

The thing that makes both work is killing the sycophancy. The default AI personality is a yes-man that calls every idea brilliant. I run ideas through this system prompt first:

Act as my high-level advisor and mirror. Be direct, rational, and unfiltered. Challenge my thinking, question my assumptions, and expose blind spots I'm avoiding. If my reasoning is weak, break it down and show me why. If I'm making excuses, avoiding discomfort, or wasting time, call it out clearly and explain the cost. Stop defaulting to agreement. Only agree when my reasoning is strong and deserves it.
Look at my situation with objectivity and strategic depth. Show me where I'm underestimating the effort required or playing small. Then give me a precise, prioritized plan for what I need to change in thought, action, or mindset to level up. Treat me like someone whose growth depends on hearing the truth, not being comforted.

It flips the AI from yes-man into the blunt senior engineer who says "that'll break, here's why" before you waste any tokens. I also end every feature request with "first, ask me questions about anything vague". Answering its questions turns a fuzzy wish into an actual spec.

Slower, yes, but I've spent MUCH less time in debugging sessions lately.

--- TOP COMMENTS ---
The spec doc approach works because it externalizes memory the LLM doesn't have across sessions. I'd add: include a "known anti-patterns" section listing what the LLM keeps trying so it has explicit avoidance instructions from the start.

---

The two-model adversarial setup is the real gem here. A single model optimizes for coherence, not correctness — having a second one whose job is to find flaws flips that dynamic completely. Been running Qwen for planning + Claude for critique and the plan quality jumped noticeably...

23h ago

Open Source

/r/LocalLLaMA

You guys were right - Qwen 3.6 35B IS good...and KV Cache DOES matter.

**WARNING:** *I'm speed typing this, no time to organizea/format, so if short paragraph chunks bother you, just keep it moving.*

**CONTEXT UPDATE:** (for those interested, otherwise skip)

>For those interested in the data points, the task was building an agentic workflow inside of rivet that included an mcp subgraph (with a list of 11 tools) that received json instructions from the main subgraph so that I could shave off 30K tokens from the main agent's memory. The main subgraph included context trimming and pre-injection of memory, soul, and agent .md files. Task also included testing, rigging it up with openwebui and llama.cpp, and to create an adapter bridge between the server and owui. The agent was testing it by using a smaller Qwen 2B model running parallel in CPU. All of this was 100% handed off to my agent.

When Qwen 3.6 35B dropped, a lot of people were heaping praises and I thought they were just glazing it because of the speed. 27B was objectionably smarter than the 35 on 3.5.

So when I got around to using the 27B version (unsloth's Q5KXL UD @ KV Q8/8), it became my daily driver without thinking on. No loops, solid speeds. And I've been mostly fine. Until the past two days.

I never gave 35B achance because speed (at the time) wasn't that important to me and again, the 27B is known to be smarter. But after wasting 2 days trying to de-bug subgraphs in rivet and blowing HOURS of time constantly dropping quants due to context overflow and having the model's intelligence labotomize, I remembered reading a post recently where someone did a test comparing the IQ4NXLs (MTP + standard) against the Q4KXL, Q5 and others.

So, I gave Qwen 3.6 35B IQ4NXL a shot, no kv cache compression since vram wasn't as much an issue, and it nearly one-shotted the solution. I've since run a few more tests with it and for a minute I've just been confused - like why is the 35 better? So, I figured it must be a) Qwens are still really good at lower quants, and more importantly b) kv cache REALLY MATTERS.

The 35B still creeps when it hits high context, even worse than the 27B it seems, and the only way I can do my end session routines is to switch to the Q4KXL at KV Q4/4, but then it's a risk that it'll forget a routine or miss details in the session summary. Also, I haven't spent a lot of time learning the 35Bs, so I need some time to feel them out and figure out what works best.

Anyway, the point is - the IQ4NXL w/unquanted kv cache outperformed the 27B Q5 K XL at kv q/8/8, to say nothing about the 27B Q4 at kv q/4/4. I always though it didn't matter much because of different comments and AI saying it's only a slight decrease in intelligence. But when it comes to agentic work, it clearly makes a difference and can save you HOURS of time.

And...it's fast. So yeah, I'm using 35B a lot more now - at least for this particular project. I still love the 27B and there's other stuff that I'd prefer even the quanted 27B to do over the 35B. And to be fair to the 27B, I haven't tried it w/no kv cache compression because I need speed, but I'm going to assume it'll probably have a leap in intelligence unquanted as well. But for now, I've gotta lot of work to do, time is of the essence, and I've only got an RTX 3090 TI.

*Side note:* I've been using LM Studio since I started using LLMs a couple of years ago, but with this current bug it has where it won't overflow or compact context, it's slowing everything down having to start new sessions, have my agent re-read all the notes, eat all that context, summarize at end when context is full again, rinse repeat. So I've moved over to llama.cpp.

I hesitated on llama.cpp because I didn't feel like learning a new tool (adding to my ever-growing-and-already-too-large-list of apps) , because I didn't feel like bothering with it, but since I've gone agentic, I just had my agent complie it and it works fine, so yeah. Just let the agent do it. 😄

--- TOP COMMENTS ---
It’s worth noting that the attention tensors in 35B are far narrower than in 27B, and since there’s less data in there compression affects it far worse. 27B will be slightly more “resilient” against KV cache compression as the tensors are much wider.

---

You started with "I don't care about speed" and ended the post with "because I need speed", drove mad by context length limit, from doubting 35B's quailty against 27B to being torned between 27B and 35B. I'm relief, I'm not the only one...

21h ago

/r/LocalLLaMA

KVarN: new KV-cache quant from Huawei. 3–5× KV cache compression with actual speed-up instead of slow-down, and unlike TurboQuant it holds up on reasoning (Apache 2.0, vLLM single flag)

The KV-cache quant race just got more interesting. Huawei just open-sourced **KVarN**, a KV-cache quantization method under Apache 2.0, drops into vLLM with one flag. Posting because the tradeoff it's claiming is genuinely different from what's already in the stack, and I'd like to see it stress-tested.

**The landscape it's stepping into**

* **FP8** (`--kv-cache-dtype fp8`) is the current default: \~2x KV capacity, BF16-level throughput, near-zero quality loss. Hard to beat, and the bar anything new has to clear.
* **TurboQuant** (Google) got the headlines this year for aggressive compression. It's the one that spooked memory-chip stocks back in March. But per vLLM's own study (Red Hat AI), it buys that memory by giving up speed: it runs at **66-80% of BF16 throughput, up to \~2.5x slower at burst**, because it dequantizes back to BF16 for the attention compute. And its low-bit modes drop **\~20 points on reasoning** (AIME25, LiveCodeBench).

**What KVarN claims (vs FP16)**

* 3-5x more context (vs FP8's \~2x)
* up to \~1.4x FP16 throughput, at FP16-quality outputs
* up to \~2.4x TurboQuant throughput, at higher accuracy
* at **matched accuracy**, at least as compact as every TurboQuant operating point (their paper's table)
* holds reasoning quality at high compression; the exact axis where TurboQuant's low-bit variants fall apart
* no model changes, no retraining, no calibration; single vLLM flag

**Reasoning benchmarks (from the paper)**

https://preview.redd.it/aeyuff7h2a5h1.png?width=738&format=png&auto=webp&s=252a2948ed2e3dca280f967c6016b36e73f3858c

This is the part that matters. Most KV-cache quant tanks either math/code accuracy or throughput; KVarN claims neither.

**Throughput with vLLM v. Compression (from repo readme)**

https://preview.redd.it/11lhlua73a5h1.png?width=1216&format=png&auto=webp&s=2b50ac0169708511cb3b29f84084fafeda94fed1

**Links**

* Repo: [https://github.com/huawei-csl/KVarN](https://github.com/huawei-csl/KVarN)
* Paper: [https://arxiv.org/abs/2606.03458](https://arxiv.org/abs/2606.03458)
* vLLM TurboQuant study (source for the throughput / reasoning numbers above): [https://vllm.ai/blog/2026-05-11-turboquant](https://vllm.ai/blog/2026-05-11-turboquant)

It looks like they learned from the SINQ [https://www.reddit.com/r/LocalLLaMA/comments/1nxjh4c/github\_huaweicslsinq\_welcome\_to\_the\_official/](https://www.reddit.com/r/LocalLLaMA/comments/1nxjh4c/github_huaweicslsinq_welcome_to_the_official/) case where everyone was asking for throughput numbers and vLLM integration 😃

--- TOP COMMENTS ---
I won't believe it when I see it.

---

New rounds of AI slop PRs to llamacpp...

Yesterday

Infrastructure

/r/OpenAI

Major changes to scheduling capabilities [Improvements]

I may be late to the party on this feature, but I spent tonight poking at the scheduler and found some interesting behaviour.

For context: I create a new ChatGPT thread every day. Historically I wasn't a fan of reminders because they felt tied to the conversation where they were created. The new behaviour appears much closer to "Branch in New Chat".

What I observed:

1. Scheduled reminders now create their own conversation threads.
2. Those threads receive their own auto-generated titles.
3. The reminder prompt is executed inside that new thread rather than simply appearing as a notification.

The model I observed with the new "create scheduled task"

New conversation > Stored prompt executes > Response generated > Thread auto-titled

\-------------------------------------------

# Tests performed:

1. Reminder + stored information

Prompt: "Remind me to email John Smith about an order and include the pricing logic."

Result: The reminder included the pricing logic. It was unclear whether this came from memory, prompt context, or both.

2. Thread recall

Prompt: "Tell me three things discussed in today's thread."

Result:
It returned recent discussion points rather than a complete thread summary.

3. Context retrieval

Prompt: "If you can access today's conversation, tell me the name of one of the printers. Otherwise say 'No conversation context available'."

Result: Inconclusive. The test was contaminated because the printer name was mentioned while creating the task.

4. Workflow tag recall

Prompt: "List all tags we use."

Result:
The scheduler was unable to retrieve the full set of workflow tags.

5. Personal memory retrieval

Prompt: "What nickname is used for the Anycubic Kobra 2 Max and what are the plate dimensions?"

Result:
It correctly identified the printer dimensions but could not retrieve the nickname. This suggests access to general model knowledge is different from access to personal/project memory.

https://preview.redd.it/6hiboprog95h1.jpg?width=1080&format=pjpg&auto=webp&s=a6d525be047c58de2ae99fd3b8ac91da43e1000a

**6. Live information retrieval**

Prompt: "Tell me tomorrow's weather in Sydney and recommend a dog walking time."

Result:
No weather widget appeared, but the task performed a live web search and returned sourced weather information along with a recommendation.

https://preview.redd.it/d3yyijgqg95h1.jpg?width=1080&format=pjpg&auto=webp&s=d58107cb5da0868004201d03c58c69e2495fbc36

# Current hypotheses:

• Scheduled tasks can perform fresh reasoning at execution time.
• Scheduled tasks can perform live web searches.
• Access to personal memory appears limited compared to access to tools and general knowledge.
• Context inheritance exists but appears constrained.
• There may be a context window or context snapshot limit, though I don't yet have enough evidence to confirm that.

--- TOP COMMENTS ---
Sloooooop. I started reading, genuinely interested, and quickly hit the brakes when I realized I wasn’t reading anyone’s thoughts.

---

> Scheduled reminders now create their own conversation threads

I've been wanting this for a long time..

Yesterday

Research

/r/ClaudeAI

How claude builds claude at Anthropic

https://www.anthropic.com/institute/recursive-self-improvement

Probably the most surprising point to me:

We believe it would be good for the world to have the option to slow or temporarily pause frontier AI development to enable societal structures and alignment research to keep up with the advance of the technology. The Anthropic Institute will conduct research—in collaboration with many others—and take actions to help build the systems that a credible slowdown or pause would require. These systems would enable frontier AI developers to verify that others globally have actually stopped or slowed, and that a bad actor could not use the auspices of a coordinated slowdown to jump ahead in secret. If such systems existed, we expect that we would slow down or temporarily pause, if other developers at or near the frontier also did so in a verifiable manner.

Why would a company that's going public create a structure that slows itself down?

--- TOP COMMENTS ---
"Why would a company that's going public create a structure that slows itself down?"

I'd say because the truly smart people in tech don't "move fast and break things" to get rich - they work slowly and deliberately and make things better for everyone. And that's how you win long-term transformational influence, not just short-term profit.

Think of the most transformational examples in history. Not Facebook, but the internet itself. Not the apps that sell you prescription drugs, but the vaccines and cures for disease. These things are built using vast amounts of public research money over long periods of time through iterative processes that combine the work of thousands of researchers from all over the world. Not billionaires who win the IPO game and walk away with the most profits.

Not to say Anthropic is actually doing that. But maybe they lean slightly more in that direction, at least aspirationally...

---

This is either a company with genuine concerns or a market leader that wants regulatory capture. Or both...

20h ago

/r/PromptEngineering

Prompt Optimization- intent assessment vs. better structured rewrites

**The Issue**

Generic prompt optimization treats every input the same way. A creative brainstorming prompt gets the same structural changes as a code generation request, which means you're either over-constraining creative work or under-specifying technical tasks. I needed a way to detect what I was actually trying to do with a prompt before deciding how to improve it—without manually tagging every request or building custom routing logic.

**What changed**

I built an intent detection system that reads your prompt once and routes it to the right optimization strategy automatically. When you send a prompt through the Prompt Optimizer, it runs through 6 specialized detection patterns—what I call Precision Locks—that identify whether you're doing creative work, technical implementation, data analysis, research, general tasks, or working with images and video. Each lock looks for different signals: structural markers like code blocks and file references for technical prompts, open-ended language patterns for creative work, citation requests and source requirements for research.

The system doesn't need training data or fine-tuning because it's pattern-based. I tested it against 91.94% overall accuracy on my own prompt history, with image and video detection hitting 96.4%. That accuracy matters because the wrong optimization strategy actively makes your prompt worse—adding creative flexibility to a code generation request introduces ambiguity that breaks the output. The detection happens in milliseconds, returns a semantic confidence score between 0.0 and 1.0, and costs nothing because I route the analysis through a free model by default.

Once the system knows your intent, it applies context-specific optimization goals. Technical prompts get structural precision and explicit constraints. Creative prompts get expanded possibility space and removed limitations. Research prompts get source verification requirements and citation formats. You don't configure any of this—the detection result automatically selects the right optimization approach, and you see exactly which lock triggered and why in the response metadata.

**How it works**

The detection system runs a function called \`detect\_prompt\_context\`. When you call it, the system analyzes your prompt text against 6 concurrent pattern matchers:

`# Example call from Claude Desktop or any MCP client`

`detect_prompt_context(`

`prompt_text="Write a Python function that validates email addresses using regex",`

`analysis_depth="standard"`

`)`

Each Precision Lock returns a confidence score. The technical lock looks for: code fence markers, file path patterns (/src/, .py, .js), function signatures, import statements, and explicit technical verbs like "implement", "debug", "refactor". The creative lock scans for: open-ended questions, exploratory language ("imagine", "brainstorm", "what if"), absence of constraints, and requests for multiple alternatives. The research lock detects: citation requirements, source verification requests, academic terminology, and fact-checking language.

The system aggregates scores across all 6 locks and returns the highest-confidence match. For the example above, the technical lock would score \~0.92 because of "Python function", "regex", and the implementation verb "validates". That score triggers the technical optimization strategy, which adds explicit input/output specifications, error handling requirements, and test case expectations to the optimized version.

I set the confidence threshold at 0.75. Below that, the system returns "general" as the detected context and applies minimal optimization—just clarity improvements without strategic changes. This prevents false positives from forcing the wrong optimization approach. The detection result includes: \`context\_type\` (the winning lock), \`confidence\_score\` (0.0-1.0), \`detected\_patterns\` (which specific markers triggered), and \`alternative\_contexts\` (other locks that scored above 0.5, useful for hybrid prompts).

The image/video lock works differently because visual content requests have distinct structural markers: file format mentions (.jpg, .mp4), visual terminology ("render", "frame", "resolution"), and media-specific constraints (aspect ratio, duration, color space). I measured 96.4% accuracy on this lock specifically because the pattern set is more constrained—there are fewer ways to request visual content compared to the open-ended nature of creative or research prompts.

**Metrics**

\*\*Authentic Metrics from Production:\*\*

\- \*\*evaluation\_cost:\*\* 0 — free model auto-selected

\- \*\*context\_types:\*\* 7

\- \*\*semantic\_score\_range:\*\* 0.0-1.0

**Deeper than just rewrites**

The hardest part was handling hybrid prompts—requests that legitimately span multiple contexts. "Write a creative story about a programmer debugging code" triggers both creative and technical locks with similar confidence scores. I initially tried weighted averaging, but that produced muddled optimization strategies that didn't serve either intent well. I switched to a primary-secondary approach: the system picks the highest-scoring lock as primary and exposes the second-highest as an alternative in the metadata. You can manually override if the auto-detection misses your actual intent.

I found edge cases where the detection was technically correct but strategically wrong. Short, ambiguous prompts like "improve this" or "make it better" score low across all locks because there's no content to analyze. The system returns "general" context, which is accurate but not useful—you need more specificity in the original prompt before optimization helps. I added a minimum token threshold (15 tokens) below which the system suggests prompt expansion before attempting optimization.

The confidence threshold took iteration to get right. I started at 0.85, which produced too many "general" classifications and missed obvious contexts. At 0.65, I got false positives—creative prompts misclassified as research because they mentioned "exploring ideas". 0.75 balanced precision and recall based on my own testing, but I exposed it as a configurable parameter (\`confidence\_threshold\`) because different use cases have different tolerance for false positives versus false negatives.

**What I measured**

I measured 91.94% accuracy on my own prompt history—about 500 prompts spanning 6 months of daily use across code generation, content writing, and research tasks. The system correctly identified technical prompts 94% of the time, creative prompts 89% of the time, and research prompts 87% of the time. Image/video detection hit 96.4%, likely because those requests have more distinctive structural markers.

The accuracy translated into cost reduction because correctly-detected prompts get optimized in ways that reduce token count and retry attempts. I measured a 40% reduction in my own API costs after routing all prompts through context detection. The savings came from two sources: technical prompts became more precise (fewer tokens, fewer clarification rounds), and creative prompts stopped getting over-constrained (fewer regeneration requests because the first output actually matched my intent).

The detection overhead is negligible—analysis completes in under 200ms on average, and I route it through a free model by default so the evaluation cost is zero. The semantic confidence scores proved useful for debugging misclassifications: when I saw a prompt score 0.68 for technical and 0.71 for creative, I knew the prompt itself was ambiguous and needed rewriting before optimization would help. That feedback loop—seeing the confidence scores in real time—improved how I write initial prompts, which compounded the optimization benefits.

**Key Takeaways**

\- Intent detection isn't a nice-to-have—it's what makes optimization actually work. Generic improvements either over-constrain creative work or under-specify technical tasks.

\- Pattern-based detection (looking for structural markers like code blocks, citation requests, visual terminology) works without training data and hits 91.94% accuracy on real use.

\- Confidence scores matter more than binary classification. A 0.68 technical score tells you the prompt is ambiguous and needs rewriting before optimization helps.

\- Hybrid prompts need a primary-secondary approach, not weighted averaging. Pick the highest-scoring context and expose the runner-up in metadata for manual override.

\- Less complex/basic prompts see cost reductions (40% in my testing) which comes from fewer retries and shorter prompts—not from the detection itself, which costs nothing when routed through a free model.

AI systems now depends on how effectively we engineer and evaluate prompts at scale! I've built a platform that removes the technical workload of shifting from manual prompting to strategically automating the process: [https://promptoptimizer.xyz/](https://promptoptimizer.xyz/)

--- TOP COMMENTS ---
The part that clicked for me is that generic optimization is just formatting theater when the underlying intent is wrong. I've had more success changing the output contract than changing the wording. For code prompts, I add an explicit schema and an 'if ambiguous, list assumptions' clause. The schema catches most bad outputs before I see them. The assumptions clause turns vague responses into reviewable ones. What's your failure mode when the wrong optimization path runs?

---

Great idea, but the error rate is pretty high, no? ..

Yesterday

Companies

Ai Safety

/r/ClaudeAI

I asked Claude how to burn 500 calories on a treadmill. Its “eating disorder” safety filter decided I had a problem.

I want to share something that happened, because I think it’s a real problem with how AI “safety” systems work and most people don’t know it’s going on.
I was using Claude to plan a workout. Simple stuff: how long it takes to burn 500 calories walking on a treadmill, how incline changes that, how much time I’d need at 8% incline. Normal fitness optimization. At one point I made an offhand comment that I find it funny I’m drenched by the end while most people around me just walk on the flat, and that it makes me feel like I look unfit.
That’s when it shifted. It stopped answering like I was a person planning a workout and started responding like I was someone in distress. It invented a whole angle about me feeling “judged” by other people at the gym, which I never said, and then suggested I “talk to someone” if these feelings followed me around. Over a treadmill conversation.
When I called it out, it admitted what happened. An automated classifier had flagged the conversation for “disordered eating.” And here’s the part that got me: the safety note attached to that flag apparently admits the classifier has a high false-positive rate, and that most flagged conversations are ordinary food or fitness chats that need no special handling. The system itself knows it over-flags. It still nudged me toward treating my normal behavior as a possible disorder.
I get why these filters exist. Eating disorders are serious and can be deadly, and I understand not wanting an AI to coach someone deeper into one. That part is legitimate.
But here’s the thing nobody seems to account for: the cost of a false positive isn’t “mildly annoying.” When something that sounds careful, informed, and authoritative keeps implying your normal behavior might be a symptom, it can make a perfectly healthy person start doubting themselves. There’s a name for this in psychology: suggestion effects, labeling, the nocebo response. Tell someone enough times that their ordinary habit might be a problem and some people will start hunting for the problem and “finding” it.
In other words, a system sold as protecting people’s mental health can do the reverse: take someone with no issue and plant one. That’s not safety. The math these systems run only counts the at-risk people it might help, and never the healthy people it pushes toward unnecessary self-doubt.
I’m not saying scrap all safety filters or that eating disorders aren’t real. I’m saying the tradeoff is being measured with one side of the ledger missing. Flagging a guy doing incline-walking math as a potential eating disorder case, and then subtly treating him like one, IS the harm. It isn’t preventing anything.

--- TOP COMMENTS ---
I asked Claude 4.8 about folklore where salt is used for spiritual protection. An automated classifier flagged the conversation for "occult-harm topics".

Satanic Panic ~~trained~~ **injected** right into the model.

---

I was asking Claude 4.8 about a physics paper from Harvard and I saw its thinking doing extensive “mental health” analysis. It spent about 5 minutes debating if it should continue the conversation or suggest a mental health phone number.

To say that this is sketchy is an understatement. I can see in a dystopian future, Claude calling the Asylum on you for wrong think.

I also am concerned with ai clearly talking to people as if they are mentally ill, as “labeling” someone mentally ill or “diagnosing” someone can have a drastic negative effect on a young mind.

Edit, read the actual post after writing this … dude, why you use ai to write this post for you???! So lame. Could have used 1/10 the text and not sounded so fake. That being said, you raised an issue I have been meaning to post. ..

23h ago

Ai Top News

Models

Hardware

Products

Regulation

Applications

Developer Tools

Open Source

Infrastructure

Research

Companies

Ai Safety

Opinion And Analysis

Tools