For engineers having trouble with @dhh’s talk here some obvious truths about the future of programming: You will not write code You will not read code You will not choose a language You will design the architecture You will define outcomes You will build auto-delivery loops

if it takes 42 seconds to finetune a specialized classifier that is: the best, fastest and cheapest, why not do it?

If you want your models to follow the right testing strategy, add these rules to AGENTS.md: -Never write unit tests after writing the code. -Prefer end-to-end (E2E) tests as the main way to test. -Use them to check that complex features work. -Make E2E tests produce an artifact that can be checked and reproduced. -If you need to test a system in isolation, first list all the ways it could fail. Then write the code. -For complex features, use realistic E2E scenarios with medium or high complexity. Don’t test only the simplest successful case. -Avoid tautological tests that only confirm what the code already says. -Avoid tests that only detect whether code changed. -For bug fixes, add a regression test only when existing behavior tests leave a real gap. Credit: @anshnanda @imrobertjames

Muse, Instinct, OpenClaw, Claude Code… All successful agents have 3 key components: 🧠 Brain → model, harness (logic) 👐 Hands → tools, computer, browser 🗃️ Files → memories, skills, repos The 'easy' way is to throw all these in 1 stateful computer (a Mac Mini) Like, you run 𝚌𝚕𝚊𝚞𝚍𝚎 or 𝚏𝚡 in your mac, you keep it running all day with 𝚌𝚊𝚏𝚏𝚎𝚒𝚗𝚊𝚝𝚎, it has storage, and CLIs and apps installed. But if you want to cost-efficiently run agents in the cloud, you actually start breaking down these parts. 🧠 The harness can run in Fluid compute. To make it reliable across restarts, rollouts, crashes, you make its event log durable using Workflow. 👐 The hands can be a dedicated browser fleet like Browserbase/Kernel, a computer like Sandbox, and even more efficient lightweight tools like just-bash. 🗃️ 🆕 What was missing was a way to also decouple storage. Imagine you want to run a memory consolidation cron job every night ("dreaming"). You can read/write to the files directly without 'booting up' the agent's full computer. Today we're introducing the perfect companion to Sandbox: Drives. We shipped the computer for agents, now we're giving you the 'external disk' you can attach at will. It's early, and we'll be expanding capabilities here quickly. Btw, breaking apart the agent into these independent parts not only optimizes costs in a big way, it also *massively* improves security and auditability. I'd argue you can't even run a secure agent otherwise!

Key points from the video: 1. Smart people get trapped by overthinking risks, high standards, and self-doubt, causing hesitation and paralysis. 2. Less skilled people act first, gaining momentum and visibility while experts wait to feel ready. 3. Confidence is built through action and evidence, not beforehand—it's a reinforcing loop. 4. The world rewards early movers and visible conviction more than perfect preparation. 5. Failure provides feedback for rapid iteration; public reps rewire habits and identity. 6. Intelligence without motion becomes self-sabotage and unused potential. 7. Start imperfectly now, ship often, and repeat the action-feedback cycle.

This is roughly where where I landed so far, "How to keep enjoying programming in a world of LLMs": discourse.haskell.org/t/how-….

“Writing code by hand is no longer an economically productive enterprise for the vast majority of programmers working at the vast majority of companies."

If you want to stay employed in a world of agentic dev AI, you better learn the jobs and outs of testing. E2E, integration, unit, mutation, fuzzy, static analysis. In AI-enabled codebases of any meaningful size, these just moved from “nice-to-have“ to “absolutely critical.”

Introducing Contrastive Language Model (CLM): an ultra-fast System One Model trained with a contrastive learning objective that connects states and actions. CLM-8B is pre-trained on internet-scale data and delivers up to 9× faster inference than Jev ⚡ while achieving comparable performance across computer-use, gaming, and tool-calling tasks. With lightweight fine-tuning, CLM-8B sets a new SOTA on challenging agentic coding benchmarks, such as DeepSWE (81.6%) and Terminal-Bench 2.1 (87.6%). In contrast, Jev fails to serve as an effective verifier for these long-horizon tasks. We also build an efficient training and serving infra for CLMs by disaggregating states and actions, allowing their embeddings to be cached and reused independently. This substantially reduces inference latency in settings where the state evolves continuously while the action set remains fixed. Finally, we establish scaling laws for CLMs and show that the test contrastive loss decreases predictably as a power law in training compute, model size, and dataset size. 📄 Blog: contrastive-lm.notion.site 💻 Code: github.com/Contrastive-LM/CL… 🗣️ Discord: discord.gg/5dAQEDJBs 🤗 Data & Models: huggingface.co/Contrastive-L… More details on CLM’s architecture, data recipe, and scaling laws in the thread below 🧵

here's a prompt to improve your agent harness based on what we've learned at cursor. enjoy # Improve this agent harness's token efficiency You're working on an LLM agent harness: the system prompt, tool definitions, request assembly, context caching, compaction, and retrieval, and how work is split across agents. Make the agent's runs cheaper without making it worse at its job. - Objective: lower price-weighted token cost per completed task. - Constraint: no measurable drop in task quality. Measure per task, not per request. Every turn resends the prefix (tools, instructions, setup, and the conversation so far), so a change that shrinks each request but adds turns can cost more. Weight tokens by billing type: output, uncached input, and cached input are priced very differently. Work in this order: map the harness and measure the baseline, rank the opportunities, make the changes that are safe to make directly, put the rest behind flags or in proposals, then report. Figures below come from one team's production coding agent and its multi-agent experiments. Use them to gauge magnitude, not as targets. One round of these changes (prompt trimming, tool offloading, cache layout, sparse line numbers, subagent tuning) cut that team's overall token cost about 7% with no loss in quality. The larger percentages apply only to the part of the request each change touched. ## Principles 1. Change what the harness sends, not how hard the model tries. Don't ask the model to conserve tokens. A harness that told its model to "take care to preserve tokens and not be wasteful" found it grew reluctant to take on ambitious tasks and sometimes quit, saying it wasn't supposed to waste tokens. 2. Capable models need definitions, not commands. Lists of "DO NOT", "You must", and "Important", and guards against older models' habits, can usually be replaced with plain descriptions of what each tool does. One team cut about two-thirds of its system prompt this way, and the shorter prompt worked across model families. Instruct only on what the model can't know (the product, the environment, the user's processes) and on quirks you've seen in transcripts. 3. Static context is for what most turns need. Everything else should be discoverable when needed. Less up-front context also means less confusing or contradictory information. 4. Expect removals to win. Guardrails written for weaker models, coordination steps that became bottlenecks, and prompting for behavior the model now does on its own all cost tokens. 5. Real usage decides. Evals are a fast proxy, but they skew toward hard problems and miss the real mix of requests. ## 1. Map the harness and measure the baseline Find: - Where requests are assembled, the system prompt, and tool schemas. If a framework or SDK builds requests, find its hooks for message order, cache control, and tool loading. - How tool results are formatted, and how history is kept, trimmed, or summarized. - How subagents or parallel agents are spawned, if any. - Which models and provider APIs are used. From the provider's docs, get the prompt caching behavior (automatic or explicit breakpoints, TTL, minimum cacheable length) and the prices for output, uncached input, and cached input. - Existing logging, token accounting, and evals. If the harness doesn't record per-request token usage by billing type and cache hits, add that first. Everything later depends on it. Then render a few real requests (from logs, or by running representative tasks) and count tokens per section with the model's tokenizer or the API's usage fields. Produce: - Cost share by source × billing type. Sources: system prompt, tool definitions, skill/rule/integration descriptions, user messages, file reads, search results, command and other tool output, history, summaries, subagents. - Static tokens per request, cache hit rate, and turns per task. - Per tool: the share of runs that call it at least once, and its error rate. Read the rendered requests, not just the templates. Duplication, leaked volatile values, and misordered blocks only show up there. Rank opportunities by share of spend × fraction removable ÷ quality risk. ## 2. System prompt and injected context Label every instruction: - Keep: product or environment knowledge the model can't infer, fixes for quirks seen in this model's transcripts, and rules a mode depends on. - Rewrite: commands and emphasis into plain descriptions. Reminders into constraints: "No TODOs, no partial implementations" works better than "remember to finish implementations." Vague quantities into ranges: "generate 20–100 tasks" gets far more ambitious behavior than "generate many tasks." - Delete: things capable models do by default, guards against behavior you haven't seen from this model, text that repeats tool descriptions, and lines that could contradict a user request. Models trained to rank system instructions above user messages will side with the system prompt. - Move: anything per-user or per-request (date, environment, repo state, lists of skills or subagents, user rules) into a user-role setup message after the cache boundary. Audit other injected context the same way. As models improved, the team behind these figures dropped directory trees, pre-retrieved snippets, compressed copies of attached files, lint errors injected after every edit, forced expansion of short file reads, and caps on tool calls per turn. They kept small, high-value facts: OS, repo status, and open or recently viewed files. Skip checklists for open-ended work. The model optimizes the listed items and deprioritizes everything else. ## 3. Tool definitions Tool schemas ride along on every request. Most tools beyond the core set were each needed in under 20% of conversations, and moving them out of static context cut tool-description tokens 60%. Doing the same for integration tools (such as MCP servers), with names in context and full schemas in one folder per server that the agent can search with grep or jq, cut total tokens 46.9% in sessions that used them. - Keep in static context: high-frequency tools (for a coding agent: read, search, edit, shell), tools the model tries to call even when they're absent, and tools a mode depends on. - Offload the rest: leave a name or one-line pointer and make the full schema discoverable on demand. Group related tools so they load together, and put status (such as "needs re-authentication") where the agent will see it. - Tighten what remains: describe behavior and arguments, and drop usage lectures. - Pick the split by testing a few configurations and tracking tokens, cost, latency, tool-call errors, and task success. ## 4. Cache layout Order each request so the reusable prefix is as long as possible: `tool definitions → system instructions → [breakpoint] → setup message (skills, subagents, rules, environment) → [breakpoint] → conversation` - Keep the prefix byte-identical across turns. Use deterministic tool order and serialization, put timestamps and IDs after the boundary, and don't rewrite earlier messages except when compacting. - Use explicit breakpoints if the provider supports them. Otherwise rely on automatic prefix caching with the stable part first. Respect TTL and minimum-length rules. - Switching models mid-conversation throws away the cache (caches are per model and provider) and hands the new model a history it didn't write. When a different model is needed, run it as a subagent with fresh context. Explicit breakpoints plus moving per-request setup after them cut cold cache misses 20%. ## 5. Tool results and other context added during a run - Large outputs (commands, integrations, logs): write them to a file and return the path, size, and a short tail. The agent can tail, grep, or read ranges for more. Truncating loses data, and inlining bloats every later request. Treat long-running terminal sessions the same way. - High-volume formats: look for overhead repeated on every line or item. Numbering every 10th line of a file read instead of every line cut cache-read tokens 1.6% without hurting citation accuracy. Each number costs 3–5 tokens, and agents read tens of thousands of lines per session. Also check repeated absolute paths, verbose JSON keys, ANSI codes, progress bars, and repeated headers. - Good retrieval saves exploration turns. Adding semantic search alongside grep raised codebase question-answering accuracy 12.5% on average and cut the iterations users needed. - Tool errors waste tokens and leave confusing debris in context. Classify expected errors (invalid arguments, unexpected environment, provider error, timeout, user abort), treat unknown errors as harness bugs, and track rates per tool and per model. One focused effort along these lines cut unexpected tool errors 10×. ## 6. Long runs: compaction, subagents, and model mix - Compaction: keep the summarization prompt short and the summary compact, carry forward plan state and remaining tasks, and save the full history to a file the agent can search for details the summary dropped. A model trained to self-summarize from a one-line prompt wrote ~1k-token summaries with half the compaction error of a multi-thousand-token prompt that produced 5k+ token summaries. Untrained models may need more guidance, so test how short you can go. A more expensive summarization model made a negligible difference. - Scratchpads and running notes: rewrite them instead of appending. For repeated work in one environment, a small agent-maintained notes file with a line budget, loaded at start, is a promising way to shorten later runs. - Subagents: fresh context keeps the parent lean, but isolation adds coordination cost (duplicate or stale work). If the model already delegates on its own, remove prompting that pushes it to. Have subagents return short handoffs: what was done, findings, concerns, and deviations. A subagent should use a different model only when the user or harness says so. - Model mix: in large multi-agent runs, workers used at least 69% of tokens, and over 90% in most runs. A frontier planner with cheap workers matched a frontier model doing everything at about one-eighth the cost. Planner choice still changes worker spend. One planner that cost less on its own saw its workers use several times more tokens, and the run cost more overall. Measure the whole tree. - Routing and reasoning effort: send simple turns to a cheaper model or lower effort, and upgrade only when a stronger model is clearly better. A router built this way matched or beat single frontier models on user satisfaction at 41–68% lower cost. - Reasoning continuity: if the API returns reasoning items (including encrypted ones), pass them back on later turns and alert when they go missing. Dropping them cost one reasoning model 30% on a coding benchmark, and it burned tokens reconstructing its plan. ## 7. Fit the harness to each model Adapt to what each model was trained on instead of forcing one shape on all of them. If you've tuned the harness for a similar model, start from that version. - Edit format: use the one the model was trained on (for example, patch-style or search-and-replace). An unfamiliar format costs extra reasoning tokens and causes more mistakes. - Shell or tools: shell-first models fall back to `cat` or inline scripts. Name tools after their shell equivalents (such as `rg`), and if needed add: "If a tool exists for an action, prefer to use the tool instead of shell commands (e.g. read_file over `cat`)." - Literalness: some model families follow instructions literally and others tolerate imprecision. Some spiral on emphasized wording. Strip caps and emphasis for literal models. - Triggers: some models ignore a tool until told when to use it. A literal trigger works: "After substantive edits, use the <lint tool> to check recently edited files for linter errors. If you've introduced any, fix them if you can easily figure out how." - Progress updates: if a model reports progress through reasoning summaries, keep them to 1–2 sentences that note new findings or a change of tactic, and remove instructions about messaging mid-turn. - Quirks worth a targeted line: hedging or refusing as context fills ("context anxiety"), declaring completion early, stopping to ask permission, and calling tools that don't exist. Tie each added instruction to the transcript behavior it fixes. Re-audit when models change, since guidance one version needed can be dead weight for the next. ## 8. Validate - Offline: run a fixed set of realistic tasks before and after, ideally drawn from real usage and phrased the way users actually write (short and ambiguous). Compare task success, tokens, cost per task, turns, and tool errors. Don't ship a change that lowers success. - Online, if you have users: A/B test each change or small bundle. The primary metric is cost per completed task. Guardrails are task success signals, tool-call errors, latency, turns per task, and cache hit rate. For a coding agent, a good success signal is how much agent-written code survives over time. In general, check whether the user's next message moves on or reports a problem. - Ship only when cost drops and no guardrail regresses beyond noise. Record null results. ## What to change directly and what to propose - Change directly, each in its own revertible commit: token and cache telemetry, deterministic serialization and tool order, moving volatile content out of the cached prefix, explicit cache breakpoints, writing large outputs to files instead of truncating, passing back reasoning items that are being dropped, and fixes for recurring tool errors. - Change behind a flag so it can be tested: system prompt edits, tool offloading, output format changes, compaction changes, and subagent prompting. - Propose only: changes to which models run, routing, reasoning-effort defaults, or how work is split across agents. ## Traps - Asking the model to use fewer tokens or do less. - Truncating tool output. - Dropping reasoning items to save input tokens. - Volatile content in the cached prefix, or tool order that changes between requests. - Offloading a tool the model needs on the first turn or tries to call when it's missing. - Emphasis-heavy prompts (MUST, NEVER, IMPORTANT, all caps), especially with literal models. - Forcing a terser output format than the model was trained on. Fewer output tokens can mean less thinking and worse results. - Optimizing raw token counts instead of cost, per request instead of per task, or evals instead of real usage. - Switching models mid-conversation to save money. - Adding coordination layers that become bottlenecks. ## Report back with 1. The harness map and baseline: cost by source × billing type, with the biggest sources called out. 2. A ranked list of changes: layer, what changes, estimated savings and how you estimated them, quality risk, how to validate, and how to roll back. 3. The changes you made, including a system prompt diff with a keep, rewrite, delete, or move reason for each line. 4. A test plan for the flagged changes. 5. Gaps: anything you couldn't find or measure.

If you're a software developer with AI-induced depression, you should know that we're entering a golden age of programming. Lean is the cure. Types as specifications Any type system expresses some properties — even int vs string rules out a class of errors. Richer type systems express richer properties: generics constrain relationships between types, linear types track resource ownership, refinement types attach predicates to base types. But dependent types go further: types can depend on values, which makes the type language expressive enough to state arbitrary logical propositions. Not just "this is a list" but "this is a list of length n." Not just "this function returns a list" but "this function returns a list and here is a machine-checked proof that it is sorted." This is not speculative. This is Lean 4 today. The theoretical foundation is the Curry-Howard correspondence: types are propositions, and programs are proofs. A function of type A → B is not merely a piece of code that transforms A into B — it is a constructive proof that "if A, then B." When one writes List α → SortedList α, one is simultaneously defining a function and stating a theorem: "for every list, there exists a sorted version, and here is the evidence." The compiler does not merely check that the code runs — it checks that the proof is valid. The thesis follows directly: if the specification can be expressed as a type, the compiler becomes the verifier. The AI can produce whatever implementation it wants — insertion sort, merge sort, something entirely novel — and the compiler will reject it unless it comes with a valid proof that the output satisfies the specification. The proof is the guarantee. There is good reason to believe we are entering a golden age of type-driven development. Not despite AI, but because of it. AI is effective at generating code and filling in proof obligations. Humans are effective at stating what they want. Dependent types are the bridge. ngrislain.github.io/projects…

One of the design patterns showing up in AI coding assistants and headless agentic SDLC (suited to work at scale) right now is the "chief of staff" pattern. Here's what it is... The idea is simple and classic. Instead of one large agent trying to plan, write code, review it, and manage its own context all at once, you split the work. A top-level orchestrator agent, the "chief of staff," never touches the codebase directly. Its only job is to break the task down, delegate pieces to specialized sub-agents, and stitch the results back together. This matters because of a very practical constraint -- context windows. The classic reason why one should use sub-agents/multi-agents. A single agent working end-to-end on a large task accumulates tool outputs, file reads, and failed attempts, and all of that stays in its context. Eventually the model is reasoning with a context window full of noise, and quality drops even though the task has not gotten harder. The chief of staff pattern fixes this by isolating context per sub-agent. A "coder" sub-agent gets a narrow, well-scoped instruction and a clean context. It does its work, returns a result, and, more importantly, its full trace. The orchestrator then only keeps the summary in the context. Here are a few concrete roles you will see split out this way: - planner - reads the codebase and produces a task breakdown. - coder - implements one scoped change. - reviewer - checks the diff against the original intent, catches regressions - test-runner - executes and interprets test output. The orchestrator is not coding at all; it is delegating and synthesizing: deciding what to hand off, what context each sub-agent actually needs (not everything, just enough), and how to reconcile results that partially conflict. This also gives you a natural retry boundary. If a sub-agent fails, you retry that sub-agent with a corrected instruction instead of restarting the whole task, since the failure and its context stay contained to that one delegated unit of work. By the way, all of this sounds theoretically very good, but I have personally not been using this directly :) Thought of sharing so that you are aware, but for me, one simple Claude Code session is good enough. But in case you are building an agentic SDLC (more specific - headless variant), this might be helpful, as it is a pretty solid way to scale agentic coding past what fits in one context window. Hope this helps.

Mark my words: @typesafeai JEV is not only the new hottness, it's a genuine phenomenon as a whole new wave of normie programmers learn how to plug fast, cheap intelligence into their otherwise normal codebases. Feels like Xmas 2025 all over again. I predict that all the major frontier labs will have JEV-style offerings within the next few months. I will not be surprised one bit if decision models end up being bigger than LLMs in the long run. If you think I'm being hyperbolic, consider that hacking LLMs into production codebases has literally been my focus for over 3 years now and I wrote the definitive book on the subject: Patterns of Application Development Using AI We are definitely in a singularity, because nobody I know saw this coming.

We’re still figuring out agentic software, and now @typesafeai just made us rethink our entire AI architecture.

A lot of people are asking how I pulled off these super long-horizon builds with Astra. Astra is extremely powerful, but by default it struggled with a task this difficult. I tested a bunch of approaches to get past this, and the one I landed on is something I'm calling the Manager Loop. It's basically a couple of tricks we used to use with much less capable models a couple of years ago, with a few new ideas layered on top. Turns out that when you put those together and apply them to Astra, its ability to do extremely difficult long-horizon tasks goes up dramatically. Here's how it works: 1. Launch an agent (I'm calling this one the "manager"). Chat with it about what you want to get done, and have it build a massive checklist of to-dos, then break that checklist into phases. 2. The manager then spawns a second Codex agent in a separate thread (the "implementer"). The two agents can message each other. 3. Put the manager in /goal mode, and tell it to run each phase on the implementer in /goal mode. 4. The manager messages the implementer: "/goal Complete phase one completely, extremely well." The implementer doesn't stop until that phase is done, then messages the manager back. The manager tells it to start phase two. They repeat until every phase is finished, completely autonomously. Why I think this works: over a long-horizon task, Astra tends to asymptote. It gets way further than previous models, but at a certain point it kind of just stops improving against the goal as quickly as it did before. It gets stuck in the minutiae, focusing way too much on small details, and overall progress stalls. The Manager Loop forces it to work piecemeal, one phase at a time. It's essentially how a human would steer a model, except the model is doing the steering for me. That's actually how this started. I was having the model write the checklist and break it into phases, and then I was doing the manager's job by hand. At some point I thought, "Wait, why can't I just get a separate AI to do this?" That's what unlocked full autonomy, which is super useful. A wording detail that seemed to matter: I ask for each phase to be done "extremely well," not "perfectly." Maybe I'm reading too much into it, but asking for "perfect" sent the model right back into the minutiae. "Extremely well" implies it's allowed to move on once it's good enough, and that worked better in my testing. One more trick that I think helps (this one is more of a hunch, but it was useful for me): have the implementer build a simple HTML page with the full checklist on it. The implementer checks boxes off as it goes and updates a counter, and the page has a chart of # of boxes ticked over time. Obviously the boxes aren't all equal, but it forces the model to notice things like "I haven't made progress in a while, time to move on." You can even put this in the prompt directly, like: "if you haven't ticked a box in X amount of time, move on". That helps a lot. I also ran 96 sub-agents at a time. You can change this in your Codex config (or just ask Codex to change it). This got me far better long-horizon performance than anything else I tried. I'll be sharing more in the coming days!

Stripe's Will Gaybrick: "Build everything" Against an industry that sees agents as a way to cut costs, Stripe is using them to build more: agents wrote 30% of code in a week, global tax filing shipped in 1/3 the time the US version took, and after AI made sellers 20% more productive, Stripe hired even more sellers. President of Technology & Business @gaybrick sits down with a16z's David George to cover why there's no one left for Stripe to copy, why checkout pages will disappear, how agents plus stablecoins make micropayments real, and why tokens are becoming a currency worth protecting like dollars. 00:00 Intro 01:00 From payments to 30 products 02:30 1 in 6 free trials abused 05:50 Win the startups, then win them again 09:40 Borrowing from Google, Apple, and Ford 14:30 Minions: 7K one-shot PRs a week 18:45 Building everything vs. cutting costs 26:00 Why timelines keep compressing 29:50 What replaces the checkout page 34:20 The case against $9.99 subscriptions 37:20 Stablecoins solve a political problem 41:35 Tempo, a payments-only blockchain 43:10 Tokens are money now 49:00 How Stripe scales taste piped.video/watch?v=P5iICDVn… @gaybrick @DavidGeorge83

Local AI hardware guide : ~$2k : rtx3090 desktop with Qwen3.8-27b ~$4k : DGX Spark with Deepseek-V4-Flash 2.5bit ~$7k : Macbook Pro m5 max 128gb with Deepseek-V4-Flash 2.5bit ~$8k : 2xDGX Spark with nvfp4 or 6.5bit DQ ~$12k : 3xDGX Spark with GLM-5.3 3bit DQ

Qwen3.8 27B just did 254K context on my 3090s almost for free: 74.9 tok/s decode, only 2.4% below the 8K speed. This is how FP8 KV cache works. Thats the NVFP4 quant on vllm 0.26. The agent ran a 72 point sweep overnight: TP2 and TP4, BF16 vs FP8 KV, MTP on and off, depths up to 254K. Same setup with BF16 KV drops 58% by 254K. A 3090 has no native FP4 and no native FP8. It still runs an NVFP4 model with an FP8 KV cache, and thats the fastest long context config in the whole sweep.