标签：#ai

"AI slop" is not a model problem. It's an engineering problem you decided not to solve. The slop is the bland, off-voice, half-hallucinated, occasionally-just-an-error-message text that your LLM emits maybe 5% of the time — and that 5% is the part users screenshot. The instinct is to fix it in the prompt: add three more sentences of "be concise, be accurate, match my tone." That treats a stochastic system as if it were deterministic. It isn't. You cannot prompt your way to a guarantee. What actually works is treating the model like any other unreliable upstream dependency: wrap it in a harness that validates, rejects, and retries before anything reaches a user. The model proposes; the harness disposes. Here's how to build one. Slop is a systems problem, not a prompt problem Every production LLM feature I've shipped converged on the same shape: the model is one stage in a pipeline, not the pipeline itself. You don't trust raw generation any more than you'd trust raw user input. You parse it, you validate it against constraints you can express in code, and you reject anything that fails — automatically, before a human ever sees it. The key insight is that most slop is detectable . Empty output, a leaked stack trace, the wrong language, a 900-word answer when you asked for 200, a banned phrase like "in today's fast-paced world" — these are all checkable with deterministic code. You don't need a judge model to catch them (though a judge model has its place at the end). You need a gate that runs on every generation, costs microseconds, and never gets tired. Think of it as five layers, each rejecting a different class of failure. Layer 1: Structured output, not freeform text The single biggest reduction in slop comes from refusing to accept prose where you can demand structure. If you ask for a JSON object with named fields and a schema, the failure modes collapse from "infinite" to "a handful you can enumerate." Use the provider's native structured-output / tool-calling

The goal, the firm said, is to develop and operate up to 5 gigawatts of additional data center capacity.

A Stanford and Tsinghua paper ran a controlled experiment earlier this year. Same model. Same task. Different harness architecture. The result: a 6x performance gap driven entirely by the system built around the model. Not the model itself. This is not a prompt engineering insight. It is a systems architecture insight, and it changes where developers should invest their time when building agentic systems. The 6x Gap Meta-Harness tested Claude Opus 4.6 across two harness configurations on TerminalBench-2. The only variable was the scaffold: the code that manages tool calls, context windows, error recovery, and state persistence. One version scored at baseline. The other, with structured tool orchestration and context management, scored 18.4 points higher. Same inference cost. Same model. Different architecture. This pattern replicates across multiple independent studies: LangChain DeepAgents (2026): Same GPT-5.2-Codex model. Harness-only changes moved it from Top 30 to Top 5. That is a 13.7-point gain. Can Bölük (Hashline, 2026): Same model, same task. Changed the edit tool format. Performance went from 6.7% to 68.3%. That is a 10x improvement with 61% fewer tokens. Vercel's d0 agent : A production agent had 16 tools. Removing 14 of them (leaving only bash) took success rate from 80% to 100%. The bottleneck was not capability. It was decision surface. Why This Matters Practically The cheapest Haiku call with an optimised harness (37.6% on TerminalBench-2) outperformed the most expensive Opus call with a default harness (58.0%). That is at 1/50th the inference cost. Most teams are optimising at the wrong layer. They swap models, tune prompts, add retrieval. The structural leverage is in how the system manages tool calls, handles state, and recovers from failure. What Changes The practical takeaway for anyone building with AI agents: Audit your tool surface. Every tool your agent can call is a decision it must make. Vercel found 16→1 tool reduction improved everything.

The YouTube-to-prestige-horror pipeline is looking very strong.

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is free and source-available on Github. Star git-lrc to help devs discover the project. Do give it a try and share your feedback for improving the project. You might not have noticed, but Chrome quietly started shipping a local AI model called Gemini Nano bundled right into the browser. No API keys. No cloud round-trips. No per-token cost. It just runs on your machine. The interface to talk to it is called the Prompt API , and it landed in Chrome 138. I spent some time going through the full API surface and built a playground that lets you experiment with every feature session management, streaming, structured output, multimodal input, response prefixing, and more in one page. This post walks you through all of it. Why does this matter? On-device AI flips the usual tradeoffs: Free at runtime — the model runs on the user's hardware, not your servers Private by default — no data leaves the device once the model is downloaded Works offline — after the initial download, no network required Low latency — no round-trip to a data centre The catch is that Gemini Nano is a small model. It's great for classification, summarization, Q&A on focused content, and structured extraction. It won't replace GPT-4 for complex reasoning. Think of it as a smart, free, always-available layer you can add on top of your existing product. Enabling the API The Prompt API isn't on by default in all Chrome builds. Enable two flags: Step 1 — Go to chrome://flags/#optimization-guide-on-device-model and set it to Enabled BypassPerfRequirement . Step 2 — Go to chrome://flags/#prompt-api-for-gemini-nano and enable both the base API and the multimodal option. Relaunch Chrome. Then visit chrome://on-device-internals to check the model download status. First use will trigger a download — Gemini Nano is a few gigabytes. The Playground I put together a single-file HTML playground that covers the entire API

Large language models are good at sounding structured. That is not the same as being structured. Ask an AI assistant to "use first principles" and it may produce a confident answer with the phrase "first principles" near the top. Ask it to "red-team this plan" and it may list generic risks. Ask it to "apply OODA" and it may give you four headings without doing the hard part: orienting against assumptions, constraints, and evidence. That failure mode is subtle because the answer looks responsible. It has the right vocabulary. It has the right shape. But the method did not actually control the analysis. I built methodology-toolkit to target that gap. The goal is not to add more clever prompts to Claude Code. The goal is to add a small layer of discipline around non-trivial decisions: classify the problem, choose methods that fit, apply those methods explicitly, verify load-bearing claims, and stress-test plans before they harden into action. Repository: https://github.com/gagharutyunyan1993/methodology-toolkit The Problem: Methodology Theater Methodologies are useful because they constrain attention. First Principles asks you to strip assumptions and rebuild from base facts. ACH asks you to compare competing hypotheses by disconfirming evidence, not by collecting confirmations for your favorite answer. OODA asks you to separate raw observation from orientation, where bias and context do most of the work. Pre-mortem asks you to imagine the plan has already failed so optimism does not screen out obvious risks. When an AI assistant merely names those methods, you get the cost without the benefit. The answer becomes longer, more formal, and more convincing, but not necessarily more correct. That is worse than a short intuitive answer because the structure creates false confidence. methodology-toolkit treats that as the core anti-pattern: If a method is named, its steps must be walked. Not hinted at. Not summarized. Applied. Methodology theater: right vocabulary, no method

Welcome back to a series of introductory articles on AI Hub, the new product feature currently in an early access program! (links: EAP Site for download, documentation ) In the last article, we covered how to create agents and agent tools directly in ObjectScript using the new %AI classes. However, sometimes, instead of creating a new agent, you just want to add some custom tools to an existing agent so you can ask your local claude code, codex, copilot or other agent of choice to query your data directly. This is where MCP Servers might come in. In this guide, we will walk through how you can create your own MCP Servers to access your data. Disclaimer: AI Hub is an early access preview, with features likely to change before production releases, any issues identified can be raised as issues on the documentation GitHub repo linked above. The EAP preview is not to be used in production settings. A very brief intro to MCP I'm going to keep this brief because there are loads of other good articles on MCP Servers Model context protocol (I recommend starting with this article from @pietro .DiLeo or this brilliant introductory video from InterSystems President Don Woodlock). Model Context Protocol is a transport protocol allowing external tools to be added to an agent . There is a discovery 'handshake' where the MCP server sends a list of tools to the MCP Client. After the tools are discovered, the agent can send requests for tool executions, including parameters, to the MCP server, which executes the tool call and returns the result. MCP servers can be remote servers, i.e. running on a different machine to a client, this usually uses a streamable http/https connection or Server-Side Events. Or MCP servers can be local servers, i.e. running on the same machine, usually using a stdio connection. An important distinction AI hub allows you to create custom MCP servers within your IRIS environment, allowing agents to access or monitor your IRIS databases, productions and statu

Most RAG tutorials I found were either "pip install langchain and you're done" or 50-page academic papers. I wanted something in between — a pipeline I could actually explain in an interview, where I understood every line. So I built one from scratch. No LangChain, no LlamaIndex, no frameworks. Just FastAPI, FAISS, sentence-transformers, and an LLM API. Here's what I built, what worked, and what broke. The architecture PDF --> extract text (pypdf) --> chunk (500 char, 50 overlap) --> embed (MiniLM-L6-v2) | v question --> embed --> FAISS top-k search --> build prompt with chunks --> LLM --> answer + sources Five Python files, ~300 lines total: File Responsibility main.py FastAPI app, 3 endpoints, prompt engineering pdf_loader.py PDF text extraction via pypdf rag.py Chunking + embedding store.py FAISS vector store wrapper llm.py Swappable LLM client (Groq / OpenAI / Anthropic) How the upload works When you POST a PDF to /upload , three things happen: 1. Text extraction — pypdf reads each page and returns the raw text. Pages with no extractable text (scanned images) are skipped. 2. Chunking — each page is split into ~500-character chunks with 50 characters of overlap. The overlap prevents losing context at chunk boundaries. CHUNK_SIZE = 500 CHUNK_OVERLAP = 50 def chunk_pages ( pages ): chunks = [] chunk_id = 0 for text , page_num in pages : start = 0 while start < len ( text ): end = min ( start + CHUNK_SIZE , len ( text )) chunk_text = text [ start : end ]. strip () if chunk_text : chunks . append ( Chunk ( chunk_id = chunk_id , text = chunk_text , page = page_num )) chunk_id += 1 if end == len ( text ): break start = end - CHUNK_OVERLAP return chunks 3. Embedding — each chunk is embedded into a 384-dimensional vector using all-MiniLM-L6-v2 . This runs locally on CPU, no API call needed. Vectors are normalized so we can use inner product as cosine similarity. def embed_texts ( texts ): model = get_embed_model () # lazy-loaded singleton vectors = model . encode ( texts

This is the concrete, runnable walkthrough for Post 1 of the Portway series . The goal: stand up a single model behind an OpenAI-compatible endpoint on hardware you already own, call it from the official OpenAI SDK, and internalize the stateless contract. Everything here runs locally for $0. What this post covers A demo.py script with two blocks: Round-trip — one chat call via the OpenAI SDK, printing the content and the usage object. Stateless proof — the same final question sent as a 1-turn message and as the last turn of a 5-turn fabricated history; both prompt_tokens values are printed alongside an explanation of the delta. Engine choice on this machine Apple Silicon Mac, 48 GB unified memory, Ollama already installed. The demo uses Ollama's OpenAI-compatible endpoint at http://localhost:11434/v1 and the gpt-oss:20b model (~14 GB). The wider Portway series uses llama.cpp on Mac (Ollama is called out as problematic for Qwen3.5 in Post 2). For Post 1 — one model, prove the contract — Ollama is fine and already on the box. Model options by available RAM The demo script works with any Ollama-served model — just substitute the model name in demo.py . The table below covers machines from 9 GB unified memory upward. Model Pull command Approx size Min RAM Notes llama3.2:3b ollama pull llama3.2:3b ~2 GB 8 GB Fastest; good for testing the contract gemma3:4b ollama pull gemma3:4b ~3 GB 8 GB Google; solid instruction-following mistral:7b ollama pull mistral:7b ~4.1 GB 8 GB Classic 7B baseline llama3.1:8b ollama pull llama3.1:8b ~4.7 GB 9 GB Best quality under 10 GB qwen2.5:7b ollama pull qwen2.5:7b ~4.4 GB 9 GB Strong at instruction + reasoning gpt-oss:20b ollama pull gpt-oss:20b ~14 GB 24 GB Used in this post's sample output On a 9 GB machine, replace gpt-oss:20b in demo.py with llama3.1:8b or qwen2.5:7b — the contract demonstration is identical. Prerequisites Ollama running locally ( curl -s http://localhost:11434/api/tags should return JSON) uv installed ( uv --version )

Here's what we read and liked this week.

The Kane Parsons' film Backrooms is expected to earn up to $90 million in its opening weekend after pulling down $38 million on Friday alone. That's not only above expectations, but absolutely obliterates A24's previous opening weekend record of $25.5 million for Alex Garland's Civil War. It's also a better opening day than The Mandalorian […]

Marcia Lucas, who edited 'Star Wars' and 'Return of the Jedi,' has died at 80.

The golden age of Microsoft's Github Copilot appears to be at an end.

Cecil Baldwin's résumé includes appearances on Gravity Falls, narrating the documentary Scream, Queen! My Nightmare on Elm Street, and performing as part of the New York Neo-Futurists theater company. But he is best known as the host of the podcast Welcome to Night Vale, a long-running fiction show that blends macabre Lovecraftian horror with absurdist […]

Meta seems to be making big bets on AI-powered hardware.

Aider is the best terminal AI coding tool I've used. But by default it sends every diff through your OpenAI or Anthropic key, which gets expensive fast on real refactors — a single 100-file repo map can torch a few dollars before Aider even reads your prompt. This post shows how to run Aider against any LLM provider — Ollama for free local runs, OpenRouter for mixed-provider routing, AWS Bedrock for the enterprise plate — through a single OpenAI-compatible endpoint. I'll use Lynkr , the self-hosted gateway I maintain, but the pattern works with any OpenAI-compatible proxy. Full disclosure: I build Lynkr. I'll point out where it loses to LiteLLM and OpenRouter further down so you can make an honest call. The setup in three commands # 1. Start the gateway npx lynkr@latest # 2. Point Aider at it export OPENAI_API_BASE = http://localhost:8081/v1 export OPENAI_API_KEY = any-value # 3. Run Aider with any model name Lynkr knows about aider --model openai/gpt-4o That's it. Aider speaks the OpenAI Chat Completions protocol; Lynkr speaks it back and quietly translates the call to whichever upstream provider you've configured (Ollama, Bedrock, Anthropic, Azure, OpenRouter, Databricks, llama.cpp, LM Studio, ...). Aider has no idea it's talking to a router. Why bother? The cost math Aider's own leaderboard shows GPT-4o and Claude 3.5 Sonnet at the top — but you don't need a $3-per-million-tokens model to rename a variable. You need it for the architecture decisions. Lynkr's tier routing splits the work: Aider call type Routes to Cost Repo map summarization qwen2.5-coder:7b (Ollama, local) $0 File edits, single-function diffs gemini-flash-1.5 (OpenRouter) ~$0.075/M Architecture / multi-file refactors claude-3.5-sonnet (Anthropic) $3/M On a typical 4-hour Aider session, 80–90% of the calls are repo-map and small-diff calls. Routing those to local + cheap models while keeping Claude Sonnet for the hard reasoning has cut my own Aider spend by roughly 70%. Your mileage will vary base

Happy to announce HeliosProxy !! Far beyond a pooling tool, HeliosProxy ** is a next-gen programmable Postgres data-plane. **Works with PostgreSQL-compatible databases , not only HeliosDB. It starts as a PgBouncer-compatible wedge, then adds the operational surface teams usually build from multiple tools: connection pooling failover and transaction replay shadow execution anomaly detection edge cache controls admin REST API embedded admin UI signed WASM plugins OCI-style plugin artifacts Kubernetes operator Terraform and Pulumi providers 22 installable Claude/Codex operator skills Install operator skills: heliosdb-proxy install skills PostgreSQL #DevOps #SRE #Database #AIcoding

It’s hard to believe how quickly the tech landscape is evolving, especially with AI/ML at the forefront. Just the other day, I had the chance to attend the Mistral AI Now Summit, and wow, what an experience! I walked in with a notebook full of questions and a mind buzzing with curiosity. I left with a treasure trove of insights, a few new friends, and even more questions. Ever wondered what it’s like to dive deep into the world of AI with some of the brightest minds? Let me take you on a journey through my day at the summit and the lessons I picked up along the way. A New Era of AI Walking into the venue felt electric. The air was thick with excitement, and the buzz was palpable. I’ve been exploring AI for a few years now, and it feels like we’re at the cusp of something monumental. Mistral’s focus on open-weight models really got me thinking. What if we could democratize AI further? Imagine a world where innovation isn't locked behind corporate walls but accessible to everyone. I remember a speaker discussing how open models can help small startups compete against big players. It hit home because I’ve been that small developer trying to fight the good fight. Real-World Applications One of the discussions that resonated with me was about real-world applications of large language models (LLMs). I’ve dabbled in a few projects where I used Hugging Face's Transformers library to create chatbots, but hearing actual use cases from businesses was enlightening. For instance, a startup shared how they used a fine-tuned model to improve customer service response times by 50%. Can you imagine the time and money saved? It got me thinking about how I could implement something similar in my own projects. Here’s a quick code snippet that I’ve found useful when fine-tuning a model for a chatbot: from transformers import Trainer , TrainingArguments training_args = TrainingArguments ( output_dir = " ./results " , evaluation_strategy = " epoch " , learning_rate = 2e-5 , per_device_tra

Last week a company nobody can name spent $500 million in a single month on Anthropic's Claude API. Not $500K. Not $5M. Half a billion dollars. In one month. Because nobody set a spending limit. Uber burned through its entire 2026 AI coding budget by April . Four months into the year, done. Microsoft quietly cancelled its internal Claude Code licenses and told engineers to go back to GitHub Copilot. All three stories broke within days of each other, and they all point to the same thing. Token-based billing, when given to an ungoverned team, is a financial weapon pointed at your own company. Every prompt, every context window, every agentic loop gets billed. An engineer running Claude Code seriously can rack up $500 to $2,000 a month just by doing their job well. The answer is not stricter policies. The answer is owning the infrastructure and making tokens free. This article breaks down exactly how to do that for a 100-person engineering team for under $1 million, with real 2026 hardware prices and honest tradeoffs. The Root Problem: You Are Renting the Meter When your team uses Claude Code or any external AI API, you do not own anything. You rent compute by the token. The model is not yours. The data leaves your building on every single request. The bill scales with how well your engineers actually use the tool. That last part is the trap. The better your engineers get at using AI, the more it costs you. Uber's Claude Code adoption jumped from 32% to 84% of their 5,000-person engineering org. That is a success story that turned into a budget crisis. Owning the infrastructure flips this completely. The better your engineers get at using AI, the more value you extract from hardware you already paid for. The Solution: Private On-Premise AI The setup is straightforward: Buy GPU server hardware once Download a state-of-the-art open-source model (free) Run an inference server that speaks the OpenAI API format Point Claude Code, Cursor, or any agent at your local endpoint

Gemini Spark helps automate everyday tasks, from inbox summaries to local event planning, but it’s unclear why Google made it a separate product.