Vibe Coding Daily · Tuesday, October 13, 2026
VIBEHOT
Karpathy: The gap in how people understand AI capabilities is turning into a funnel
Andrej Karpathy thinks the gap in how people understand large language model capabilities is widening, shifting from a general difference in perception into a funnel-shaped hierarchy, and he lays out three layers of reasons. The same day, several posts zeroed in on Agent engineering practice: Claude Code's system prompts and tool design, orchestrating multi-Agent teams with YAML, and treating prompt caching as an engineering problem rather than string handling.
Practice and tutorials
System Prompts and Tool Design for Business Agents: Insights from Claude Code
By analyzing Claude Code's system prompts and tool implementations, the author concludes that the core of a business agent comes down to the system prompt plus tool design. He breaks down the layered structure of the prompt—identity statement, safety constraints, system behavior rules, task execution guidelines, tool descriptions, tone and style, and environment information—and suggests organizing it in this order: background role and goals, system guidance, business workflow, additional guidance, and tool format and environment.
Stop Treating Prompts as Strings: Engineering Prompt Caching in AI Applications
The author argues that prompt caching shouldn't be treated as caching the entire request result. Instead, prompts should be split into a base policy layer, a business knowledge layer, and a request context layer, caching only the stable segments.
Adding a decision ledger to Codex Plan mode with codex-plan-ledger: recording choices and checking scope drift
codex-plan-ledger writes decisions from Codex Plan mode (/plan) into docs/plans/<id>/decisions.json in the repo, so they can be diffed and reviewed in the same PR as the code, and uses plan-ledger check --base main to compare changed files against the plan, reporting out-of-plan changes and in-plan files that were never touched.
I rewrote the memory system for tt-agent, my Go LLM Agent framework, and hit two real bugs in three days.
I rebuilt the memory system for my Go multi-protocol LLM Agent framework, tt-agent, moving semantics like budget truncation, system message retention, and tool_calls pairing down into memorystore.Store. The driver layer only reads and writes bytes, and Redis, SQLite, and PostgreSQL backends share one set of contract tests.
LangGraph + MCP in Practice: Building a ChatBI Agent That Queries Data in Natural Language
The author used LangGraph to orchestrate the workflow and MCP to wrap database operations, building a ChatBI agent that lets users query the database in plain language and get results back automatically. The flow goes: intent recognition, fetching table schemas, generating SQL, validating SQL, executing the query, and interpreting the results. The MCP Server exposes only three tools—list_tables, get_table_schema, and execute_sql—and enforces read-only validation.
Turning Socratic questioning into AI prompts: a four-variable, three-stage framework
The author proposes a framework for porting Socratic questioning into AI prompts, using four variables — role, mining goal, questioning dimensions, and output format — plus a three-stage flow of rough interview, deep interview, and targeted output, so the AI asks the user one question at a time. The article includes a reference table of 7 questioning dimensions such as STAR, 5W2H, and motivation-pain point-decision-turning point, along with three copy-paste-ready prompts for turning work experience into a resume, plus one that has the AI interview the user in turn, helping define the four variables and generate them.
LangGraph in Depth: From Single-Agent Pain Points to Multi-Agent Orchestration in Practice
The article starts from the pain points of single agents—high context overhead, information interference, and the inability to run in parallel—and explains how splitting work across multiple agents can cut token consumption and improve accuracy. It also gives the formula: Agent = LLM + Harness.
Problems and incidents
LLM-Driven Automated Testing (10): How Healenium's Heuristic Scoring Compares to LLM Semantic Self-Healing Under the Hood
The author decompiled the bytecode of tree-comparing-0.4.14.jar from Maven Central and confirmed that Healenium's claimed machine learning self-healing is actually a hard-coded weighted scoring formula, with weights TAG=100, ID=50, CLASS=40, and VALUE=30. Similarity is computed using Levenshtein edit distance, with no training or inference involved.
New tools and Skills
OpenRig teardown: using YAML to turn Claude Code and Codex into a team
OpenRig is an open-source multi-agent harness that defines team topology with a YAML-based RigSpec, turning sessions like Claude Code and Codex into a team. This week it climbed GitHub trending with 2,028 stars, bringing the total to nearly 7,000. The current version is 0.6.10, under the Apache-2 license.
Open-source tool REA gained 81000 stars in a matter of days and can plug into Claude Code for reverse engineering software.
The open-source project REA (Reverse Engineer Anything) hit the top of GitHub Trending within days of launch, gaining 81000+ stars. It offers a reverse-engineering workflow that plugs into agent tools like Claude Code, Codex, and Cursor.
Ideas and discussion
Karpathy says the gap in how people understand AI capabilities is turning into a funnel, and he lays out three layers of causes
Andrej Karpathy thinks the gap in people's understanding of large language model capabilities is widening, shifting from "two groups talking past each other" into a funnel. He estimates that roughly 6000000000 people have barely touched large language models, 1000000000 to 2000000000 people occasionally use free ChatGPT-like products, about 20000000 people (0.2%) use frontier models heavily for math and programming, and around 5000 people can use stronger systems internally.
Addy Osmani: Agent code quality comes from validation loops, not line-by-line review
Addy Osmani argues that the key to agents writing code that is “better on average at scale” is validation, because agents make checking cheap. The tests, benchmarks, specs, and real end-to-end runs that used to make “good code” expensive can now be handled directly by agents, so the focus shifts from line-by-line review to building loops the agent can run on its own, giving it the means to verify its work. He also suggests writing the mistakes an agent has made into shared config, hooks, or tests so the experience compounds. Humans are still accountable for shipping, but they look at evidence rather than just the diff.