标签：#ai

我讓三個 AI 各司其職寫程式：Codex 出測試、Grok 寫實作、Claude 驗收 這週我沒有讓單一 coding agent 從頭包到尾。我把流程拆成一條固定的契約： Codex 先寫測試，Grok 再寫實作去讓那些測試通過（只能改實作、不准動測試），Claude 獨立驗收才提交。 測試在實作之前就寫死，成為 Grok 必須滿足、且不能修改的規格。我先在一個 Zig 專案跑了兩個功能，後來又在一個 Rust + Turso 專案獨立重跑三個功能（見文末）——判斷一致：這條 pipeline 在 有嚴格測試當契約 的前提下可用；它省下的不是人力，而是把「錯誤發現點」往前、往獨立處移。這只是 workflow 可用性判定，不含可商用判定——後者要另算 token/seat 成本、隱私、rate limit 與審計，本文不碰。 實驗條件（可自行驗證） 工具： codex-cli 0.142.4 、 grok 0.2.77 (44e77bec3a) 、Claude Code（CLI，版本未記錄，屬已知量測缺口）。 專案：一個 Zig 0.16.0 codebase（私有 repo，commit hash 僅供我本地對照），加一個「回合後反思」功能。另在一個 Rust + Turso 專案上以同一條 pipeline 再跑一輪，見文末「換一個 stack 再驗一次」。 樣本：Zig n=2 個功能 （config surface、reflection module），共 15 個測試（4 + 11）；Rust + Turso n=3 個功能 （見文末）。兩者各自樣本都小。 出題命令： codex exec --sandbox read-only （單次、不寫檔）。 施工命令：Grok headless、可寫檔模式（write→test→fix）。 觸發 400 的命令：對 grok-composer-2.5-fast 傳 --effort （等同 reasoningEffort 參數）。 驗收命令： zig test <libs> --dep build_options --dep compat -Mroot=src/root.zig --test-filter "<功能前綴>" ；leak-detecting allocator 回報 0 leak。 樣本小，數字不外推；以下每個論斷都設計成能被另一個工程師在幾分鐘內驗證或反駁。 核心迴圈：測試先寫死，實作去追它 每個功能走五步，順序不可換： Codex 出測試 + 最小 stub 。stub 讓測試「能編譯、但在斷言上失敗」——這是真正的 RED，不是因為符號缺失而編不過。測試此刻就固定下來，之後不再改。 Claude 對照原始碼核對 測試。Codex 會猜 API（vtable 欄位、函式簽章、建構模式），必須逐一驗證符號存在才落地。 Claude 放進隔離的 git worktree ，跑到確定 RED：pass/fail 混合，每個失敗各有其原因。 Grok 寫實作 到 GREEN。任務只有一句： 讓這些已寫死的測試通過，只改實作、不准動測試。 測試是 Grok 不能碰的契約，不是它可以順手改綠的東西。 Claude 獨立驗收 （不採信 Grok 的自述）：跑測試、確認 0 leak、核對 diff 的正確性與改動範圍，才提交。 重點不是「三個比一個強」，而是 出測試的人跟寫實作的人不是同一個 agent ——測試因此成為獨立的規格，實作成為獨立的檢查。一個模型不能同時定義正確、又判定自己是否正確。 對照三個真實替代方案 單 agent 跑 TDD（自己出測試、自己實作） ：最快，但自我驗證風險最高。 人寫測試 + agent 實作 ：最可靠，測試由人把關；代價是人工成本最高。 本文的三 agent 分工 ：增加 orchestration 來回（見下），換到的是「假綠」風險下降——任何一環的自欺會在下一環被抓到。 選哪個，取決於你的錯誤成本 vs. 來回成本。 每家 CLI 的落地差異（用法決定，不是廠商能力差異） 三家我都只用了各自的一種模式，差異來自我怎麼接，不是模型智力： Codex ：我用 codex exec --sandbox read-only 的 單次 模式，讓它只「輸出」測試碼、不改檔。它其實支援 --sandbox workspace-write 與 exec resume （可多輪、可寫檔），但我刻意把它限縮成「出題者」，讓出題與施工不同源。誤把單次 read-only 模式當施工者用，會得到看似對、實際編不過的檔案。 Grok ：我用 headless、可寫檔模式跑 write→test→fix。踩到一個 參數相容性 的坑：在 grok 0.2

Here's an uncomfortable truth nobody wants to admit out loud: most teams can generate a working app in minutes now, but almost none of them can ship it to production without breaking something important. Only a small fraction of organizations have actually moved their AI-built systems past the pilot stage. The gap between "it works on my machine" and "it works for real users" has never been wider, and closing that gap is quickly becoming the single most valuable skill a developer can have this year. If you have been prompting your way to a working prototype and then hitting a wall when it's time to actually deploy, this guide walks through exactly how to close that gap, with working examples at every step. Why This Matters Right Now Vibe coding, meaning describing what you want in plain language and letting an AI model scaffold the implementation, has gone from a novelty to a default workflow. Developers are shipping REST APIs , auth flows, and full CRUD apps with a single well-written prompt. But speed of generation is not the same as readiness for production. Untested edge cases, missing validation, weak error handling, and security gaps show up constantly in AI-generated code because the model optimized for "looks correct" rather than "survives real traffic." The developers who stand out this year are not the ones who can generate code fastest. They are the ones who know how to validate it, harden it, and integrate it responsibly. Below is a practical checklist you can apply to any AI-generated codebase before it touches a real user. Step 1: Treat the AI Output as a First Draft, Not a Final Answer Say your AI assistant generates this login handler: \ javascript // AI-generated first draft app.post('/login', async (req, res) => { const { email, password } = req.body; const user = await db.query( SELECT * FROM users WHERE email = '${email}' ); if (user.password === password) { res.json({ token: generateToken(user) }); } }); \ \ Looks functional. It is also a SQL in

If you’ve spent any time poking around the AIE World’s Fair 2026 website, you may have come across...

The AI Engineer World's Fair here in San Francisco is fundamentally a conference for practitioners —...

Many of the sessions from Tuesday, especially on the main stage, revolved around the idea of software...

Crossword puzzles are easy. But what if you had to solve one while running inside the hardware constraints of a Large Language Model?

As you’d expect, the opening keynote of the AI Engineer World’s Fair was kicked off by one of its...

As AI agents work under increasingly less human supervision, the need for a trustworthy, secure work...

Software engineers have become overreliant on models to build applications, and it’s time to put...

What Claude Sonnet 5 Means for AI Infrastructure in East Africa The release of Claude Sonnet 5 on June 30, 2026 changes something specific about building AI agent infrastructure for regions like East Africa: the model tier that couldn't reliably finish a multi-step workflow now can. This isn't a general AI update note. It's about a concrete technical constraint that just moved. The constraint that moved East Africa's AI infrastructure problem isn't compute or APIs. M-PESA has an API. Africa's Talking has an API. NDMA publishes drought data. KRA has a taxpayer portal. The constraint has been that an AI agent calling several of these in sequence — check drought severity → trigger insurance evaluation → notify county — would stop partway through, lose context, or require manual handholding to continue. Sonnet 4.6, released in February, scored 67.0% on Terminal-Bench. Sonnet 5, released today, scores 80.4%. That 13-point gap isn't abstract. It's the difference between an agent that stalls at step two of a cascade and one that finishes. What this means for the East Africa coordination stack The 31 MCP servers in this portfolio — covering M-PESA, drought data, tax, credit scoring, crop insurance, land records, labor rights, county data, and more — are now meaningfully more useful as a system than they were yesterday. The key change: africa-coord-bus , the coordination event bus that connects these servers, is now the kind of tool Sonnet 5 was designed to orchestrate. A drought alert from wapimaji-mcp , cascading through bima-mcp for insurance evaluation and county-mcp for notification, is exactly the multi-hop tool chain where the 13-point Terminal-Bench improvement shows up in practice. The model to use # Claude API client = anthropic . Anthropic () response = client . messages . create ( model = " claude-sonnet-5 " , max_tokens = 1024 , tools = [...], # your MCP tools messages = [{ " role " : " user " , " content " : " ... " }] ) For compliance and vulnerability analysi

The problem every AI coding session hits You open Claude or Copilot, paste in your task, and immediately hit the wall: the codebase is too big. You either: Dump everything and burn 80% of your context window on irrelevant files Hand-pick files and miss the one import that breaks everything Pay for a bigger context window and repeat the problem at scale I got tired of this and built ContextOS — a local CLI that acts as an intelligent context layer between your repo and your AI agent. What it does pip install rm-contextos cd your-project contextos scan contextos pack --task "add rate limiting to the auth endpoint" --budget 8000 Output: a Markdown (or JSON) context pack with only the files that matter for that task — ranked by keyword match, import graph centrality, AST symbol overlap, and git churn. Secrets redacted automatically. Token savings report on every pack: Packed 12 files · ~6,840 tokens · saved ~47,200 tokens (87%) vs full repo How ranking works Five signals combine into a score per file: Signal What it catches Keyword match Files whose content/name overlap with your task Import graph centrality Files that everything else imports (critical shared modules) AST symbol overlap Function/class names, not just grep strings Git churn score Recently modified files are probably active code Secret penalty Credential files silently excluded No LLM calls. No cloud. Fully offline. MCP server (for Claude Desktop / Claude Code) pip install "rm-contextos[mcp]" contextos serve --stdio Register in claude_desktop_config.json and your AI agent can call pack_context , scan_repo , list_files , get_file , churn_report directly as tools — no CLI needed. What's shipped 980 tests, 96% coverage Apache-2.0, no telemetry, no accounts Python 3.11–3.13, Linux + macOS Export formats: Claude, Codex, Cursor, Aider, JSON Incremental scan cache — re-scans only changed files pip install rm-contextos pip install "rm-contextos[mcp]" # + MCP server pip install "rm-contextos[all]" # everything Git

The Gemini macOS app now has access to Google's Spark agentic AI assistant.

从思想到工程：FROST 与 FROST-SOP 的双生之旅 你知道吗？每一个伟大的工程背后，都有一个简单而深刻的起点。 引言：从 500 行到 5000 行的演进 在开源世界里，我们见过太多"大而全"的框架——它们功能丰富，却让人望而生畏。今天我想分享一个反其道而行之的项目： FROST 。 FROST （Fractal Runtime of Orchestrated Skills & Tasks）最初只是一个 500 行的教学框架，用最朴素的代码讲述 Agent 的本质。它的核心哲学只有一句话： 细胞会死，但谱系会存续。Agent 会消亡，但宪法会传承。资产会永存。 而今天我要介绍的，是 FROST 思想"开花结果"后的工程实践—— FROST-SOP ，一个拥有 5000+ 行代码的完整 Agent 工程平台。 FROST：理解 Agent 的钥匙 FROST 不是什么复杂的框架。它的设计哲学是 最小原子集 + 分形宪法 ： 四个原子，理解一切 原子 职责 生物学类比 Store 记忆容器，只做 save/load/delete 细胞核 Skill 纯能力单元，无状态无副作用 蛋白质 Agent 膜包裹的细胞，拥有 Store + Skills 神经细胞 SOP 有序步骤列表，可教学、校验、优化 宪法文本 from core import Store , Agent , skill_set , skill_get store = Store () agent = Agent ( " cell " , store , skills = { " set_context " : skill_set , " get_context " : skill_get }) result = agent . run ( sop_steps = [ " set_context " , " get_context " ], initial_context = { " key " : " message " , " value " : " FROST is alive " } ) # result["_result"] == "FROST is alive" 5 行代码，你就能理解整个 Agent 系统的运作原理。这就是 FROST 的魔力—— 用最少的代码，讲述最深的道理 。 五维元模型（V4.0/V5.0） FROST V4.0 引入的五维元模型，将框架从扁平升级为多维度 Agent 编排系统： 武器注册表 ：能力的元数据管理与发现 任务注册表 ：DAG 任务编排与图谱 SOP 事件编目 ：态势感知与双模式事件分析 平台注册表 ：外部能力的发现、调用与健康检查 规则注册表 ：可版本化的治理约束与合规检查 197 个测试用例保障质量，最新 Release： FROST v5.0.0 FROST-SOP：思想的工程化 FROST 教会我们理解，FROST-SOP 教会我们构建。 事件驱动的 Agent 家族 FROST-SOP 实现了完整的 祖辈 → 父辈 → 子辈 三层递归架构： import asyncio from core.event_bus import get_async_event_bus , Event , EventType from agents.ancestor import create_ancestor from agents.parent import create_parent async def main (): bus = get_async_event_bus () # 创建事件驱动的 Agent 家族 ancestor = create_ancestor ( constitution , asset , event_driven = True ) parent = create_parent ( " parent-1 " , store , event_driven = True , asset_store = asset , sop_id = " DEV-001 " ) # 发布任务，Agent 家族自动响应 await bus . publish ( Event ( event_type = EventType . TASK_CREATED , source = " user " , data = { " task_id " : " task-001 " , " task_description " : " 开发一个用户登录功能 " } )) await asyncio . sleep ( 10 ) asyncio . run ( main ()) 完整的工程特性 特性 说明 19 个内置 Skill

I have been building AI products for a while and kept running into the same problem. Every project that involves querying documents with AI requires the same foundation before you can build anything interesting: a chunking strategy, an embedding pipeline, a vector database, re-ingestion logic when content changes, and a retrieval layer on top. It is not hard, it is just a lot, and it is not the part you actually want to be building. So I built Kognita to handle it as a managed API. You push content in via API, text or files, and get back hybrid search over a knowledge base. Kognita handles chunking, embedding, indexing, and automatically re-embeds when you update content. It is opinionated: we pick the embedding model and chunking strategy. The trade-off is less flexibility for a much faster path to a working knowledge layer. What we are looking for We want 10 teams who are building something that needs a knowledge layer and are willing to test it honestly. The ask is: what broke, what was confusing, what you needed that was missing. Not looking for compliments. Looking for people who will actually use it and tell us where it falls short. What you get Unlimited knowledge bases 10 GB storage 100 GB egress per month 50 GB file storage No credit card. No time limit. Higher than our standard paid plan. Who it is for Engineering teams building AI features over documents who do not want to manage the underlying infrastructure themselves. If you need full control over your embedding models or retrieval strategies, this is probably not the right fit. If you want to skip the pipeline and get to building, it might be. How to get started Sign up at kognita.io. Drop a comment here if you sign up and I will make sure you are on the early adopter tier.

Vinton Cerf, one of the creators of the protocols underlying the internet, will step down as Google's chief internet evangelist next week.

Written from months of grinding on shielded liquidity DeFi protocols on Midnight. If you've been trying to build anything serious with shielded fungible tokens on Midnight lending protocols, liquidity pools, DEXes you've probably hit some walls that the documentation doesn't fully prepare you for. The Midnight programming model around shielded tokens is genuinely different from anything in the EVM world, and a lot of the intuitions you carry from Solidity or even other ZK environments will get you into trouble fast. This post is a breakdown of the most impactful errors and misconceptions I ran into while building shielded liquidity DeFi contracts using Midnight's Compact language. These are not theoretical every single one of these either broke a circuit or caused a proof server failure at some point. I'll walk through what the issue is, why it happens, and what the correct pattern looks like. Background: How Shielded Tokens Actually Work Under the Hood Before we get into the errors, let's get clear on the underlying mechanics because this context is what makes the errors make sense. Midnight uses a protocol called Zswap for shielded token operations. When a user sends tokens to your contract by calling receiveShielded , what actually happens is more involved than it looks on the surface. When your circuit calls receiveShielded(coin) , the Compact runtime records a shielded receive obligation in the transaction being constructed. At this point, the proof server kicks in to generate the ZK proof for your circuit. But here's the thing your circuit only describes what the contract side is doing. The transaction still needs to be balanced : the tokens being received by the contract have to come from somewhere. This is where the wallet gets involved through an internal mechanism that runs beneath your circuit. The wallet looks at the ShieldedCoinInfo you're receiving the coin's color (token type) and value and finds a matching UTXO in the user's private coin set. It then

Breaking long documents into overlapping chunks, preserving context, and reassembling with FastAPI At LectuLibre, we’ve built an AI‑powered platform that translates entire books—EPUBs and PDFs—using large language models. When we first hooked up Claude’s API, we naively fed it a 300‑page PDF in one request. It failed immediately. Claude 3 Opus has a 200K token window, but a 300‑page book can easily run to 300K tokens or more. Even if we squeezed it in, the output would be truncated and the quality would degrade at the extremes of the context window. So we faced a classic long‑document problem: how do you translate a book that’s larger than the model’s context window? Here’s the real approach we ended up with, the code we wrote, and the lessons we learned. The Problem: Token Limits Are Real Claude 3 Opus and Haiku models (and most LLMs) have a maximum context length—200,000 tokens for Opus. A token is roughly ¾ of a word. A 300‑page novel with ~75,000 words translates to about 100K tokens, so it should fit, right? But translations from English to Spanish can expand by 15–20%, and the prompt instructions, system message, and the user message itself all eat into that budget. Plus, we needed to send the entire source text in every call to give the model full context. That’s not feasible. We could have tried a simple split: cut the book at arbitrary page boundaries and translate piecemeal. That fails spectacularly. Narrative breaks mid‑sentence, and phrases like “the previous chapter” lose their referents. We needed a more intelligent chunking strategy. Our Approach: Sliding Window with Overlapping Paragraphs We settled on a sliding window chunking algorithm based on paragraphs, with a generous overlap. Here’s the idea: Split the source text into paragraphs (using \n\n ). Build chunks of max_chunk_tokens (we used 180,000 to keep a safety margin), adding paragraphs one by one and counting tokens with tiktoken . When the chunk exceeds the limit, we start a new chunk but we

Anthropic said it would begin restoring access to the Fable on July 1.

Wayve’s offering is part of a growing trend of AI startups using employee tenders as a strategic tool to attract and retain talent.

Anthropic will start its users' access to Mythos and Fable tomorrow, July 1.