1. selling AI agents 101 — Chris

  • Why read: How to sell AI to local businesses: start with trust, not tech.
  • Summary: Pitching complex automation to traditional SMBs usually fails because it scares them. Start with a cheap, easy-to-understand wedge product, like a $99/month social media poster. Use that to build a relationship and uncover their real bottlenecks, like manual quoting or messy spreadsheets. Then, sell them a $5,000/month custom system to fix the core problem. Because businesses in the same vertical share the same problems, you can build this expensive system once and sell it repeatedly.
  • Read more

2. How to build your own LLM in 3 tiers: the path nobody explains before you waste $10M — Moysei

  • Why read: A guide to custom LLMs that explains why you shouldn't train a model from scratch.
  • Summary: Training a foundation model from scratch costs millions and is rarely necessary unless you are a frontier lab. For most companies, the right move is fine-tuning an open model like Llama 3 or Mistral using QLoRA. This technique freezes the base model and trains a small adapter on your data. It costs under $20, finishes overnight, and gives you a model tailored to your specific domain without the massive compute bill.
  • Read more

3. Routing to models is genuinely hard — Madhu Guru

  • Why read: Defaulting to the smartest model for every task is getting too expensive. Model routing is the fix.
  • Summary: Open models are catching up in performance, but frontier models remain much more expensive. Companies are burning cash by using high-end models for basic tasks. The fix is intelligent routing: sending volume tasks to DeepSeek, complex agents to Claude, and reserving GPT-5.5 for the hardest problems. Building a control plane to route these requests based on cost and capability will soon be a standard requirement for managing enterprise AI spend.
  • Read more

4. As I wrote this, I saw X go into meltdown... — Eric Glyman

  • Why read: Why tracking API tokens is a terrible way to measure AI ROI.
  • Summary: Exploding AI budgets are causing panic, but the real issue isn't the cost—it's that we measure the wrong thing. Tokens track compute, but they don't tell you if a customer issue was resolved or a lead was qualified. Finance and engineering need a shared framework to evaluate AI spend based on actual business value, treating it more like headcount allocation. The companies getting it right are doubling their revenue, partly by routing simpler tasks to cheaper models to protect margins.
  • Read more

5. Self-reflection on Coding’s Real TAM — Freda Duan

  • Why read: Why sizing the AI coding market based on software developer seats is a massive underestimation.
  • Summary: Early estimates priced AI coding tools like SaaS seat licenses. If these agents actually do the work, the better benchmark is developer salaries, pushing the market into the hundreds of billions. Beyond that, code is the underlying interface for all digital knowledge work. As coding agents get better at retrieving context and updating systems, they will start automating general enterprise workflows, expanding their addressable market far beyond software engineering.
  • Read more

6. How NVIDIA's SkillSpector works and How to add It to your skill PRs — Daniel San

  • Why read: How to secure AI agents from untrusted third-party code and prompt injections.
  • Summary: When AI agents pull in external tools or prompts, they open up a massive attack surface. NVIDIA's SkillSpector works as a static scanner for agent skills, checking for prompt injections, data exfiltration, and supply chain vulnerabilities. By adding it to your CI/CD pipeline, you can automatically block pull requests that introduce security flaws. If you are deploying agents in an enterprise environment, this kind of automated risk scoring is quickly becoming a requirement.
  • Read more

7. How to Make Claude Code Stop Making Stuff Up When It Doesn't Know (Exact Setup Inside) — rody

  • Why read: A configuration guide to force Claude Code to admit when it doesn't know something.
  • Summary: Claude Code defaults to guessing when it lacks information, which leads to fabricated functions and imports. You can fix this by updating its local configuration. First, add rules that explicitly tell it to say "I don't know." Second, force it to run `grep` or read a file to verify symbols before using them. Finally, use real-time hooks to run linters and type checkers as soon as it writes a file. These constraints make it harder for the agent to guess than to verify.
  • Read more

8. How to Build a Claude Agent Team: One Writes Code, One Reviews, One Deploys (Exact Config Inside) — Hanako

  • Why read: Splitting coding tasks across three specialized AI agents improves reliability.
  • Summary: A single agent writing, reviewing, and deploying its own code creates obvious blind spots. A better setup uses three agents with separate prompts and constraints. A "Writer" handles implementation, a "Reviewer" looks for edge cases, and a "Deployer" ships the final output. You can connect them through a shared directory and an automated cron loop. This separation of concerns creates a much more reliable autonomous workflow.
  • Read more

9. Economy of Minds: Multi-Agent Prompt Optimization explained — AVB

  • Why read: Using internal bidding markets to coordinate multi-agent workflows instead of hand-coded logic.
  • Summary: Building orchestration logic for multiple agents is usually fragile and manual. A new paper, "Economy of Minds," proposes an internal market where agents bid to take actions in a workflow. Instead of writing a state machine, developers set up incentives. The agents then organically determine the optimal routing and role switching as they adapt to the task. It shifts the developer's job from hardcoding behavior to designing market rules that produce coordinated action.
  • Read more

10. frontier agents are this good partly because the model was... — Sergio Paniego

  • Why read: Top coding agents get their performance edge from being trained directly inside their execution environments.
  • Summary: Frontier agents don't rely on scale alone. NVIDIA research shows that turning tools like Claude Code or Codex into reinforcement learning environments drives massive gains. Researchers use a proxy API to capture successful token trajectories during tool execution, then map gradients directly to those tokens. Instead of just training a language model, they co-optimize the model and its specific harness. This approach helps open-weight models compete above their class in agentic tasks.
  • Read more

11. Turn the stuff you keep asking Claude Code/Codex to do into actual tools — Vox

  • Why read: Stop writing the same prompts and turn routine tasks into permanent repo tools.
  • Summary: If you find yourself typing the same instructions for bug triage or code reviews, you are wasting time. You should codify those patterns into permanent artifacts, like markdown checklists, CLI scripts, or agent skills. By committing these to the repository, the AI can read your rules for inputs and outputs without needing to be told again. Define what you want the end result to look like, then have the agent build the tool to get there.
  • Read more

12. How I set up Obsidian + Claude as my second brain — rari

  • Why read: How to connect Claude to Obsidian so it can reason across your local notes.
  • Summary: Keeping Obsidian as a static file system and Claude as an amnesiac chatbot is a missed opportunity. Fusing them turns Obsidian into a memory layer and Claude into a reasoning engine that understands your context. Using plugins like Smart Connections, Templater, and Dataview ensures the AI can properly read and format your data. You can use this setup to generate morning briefs, clean up meeting notes, and synthesize research against your personal archives.
  • Read more

13. Feedback loops: Help Claude Code complete ambitious tasks with less babysitting — Delba

  • Why read: How to reduce babysitting by giving agents the tools to verify their own work.
  • Summary: Agents need to do more than check for type errors if you want them to handle ambitious tasks. You can reduce manual oversight by turning your verification steps—like UI testing or accessibility checks—into agent skills. By giving the agent access to tools like Chrome DevTools MCP, it can spin up a browser, check the console, and review performance traces on its own. When an agent can evaluate its own work against a rubric, it cuts down the back-and-forth required to finish a feature.
  • Read more

14. Who will build Vercel for agents? — Hunter Leath

  • Why read: Why agent deployment platforms are struggling: agents need shared file systems, not just stateless compute.
  • Summary: Current deployment platforms treat agents like traditional web apps, which rely on stateless compute and external databases. But agents are highly stateful. Their execution loops and sandbox environments require simultaneous, shared access to file storage to manage context and run tools. The bottleneck for agent infrastructure isn't compute or networking—it's building the right shared file-system primitives for distributed environments.
  • Read more

15. /problem-first: a simple skill to invert bad ideas — George from 🕹prodmgmt.world

  • Why read: How to use an AI prompt to reverse-engineer bad feature requests into core user problems.
  • Summary: When teammates pitch fully baked, flawed features, pushing back creates political friction. Instead of rejecting the idea outright, treat it as a symptom of a hidden pain point. The `/problem-first` prompt workflow takes a feature request and works backward to find the root cause and hidden assumptions. It shifts the conversation from rejecting a roadmap item to investigating the real user friction, helping PMs triage ideas without burning goodwill.
  • Read more

Themes from yesterday

  • Agents over Chat: Moving from conversational bots to autonomous workflows by building reusable tools, self-verifying loops, and multi-agent setups.
  • Model Routing for Cost Control: Token spend is out of hand. Teams are protecting margins by routing routine tasks to cheaper, open models.
  • New Infrastructure Bottlenecks: Scaling agents means solving new architectural problems, like shared stateful storage and securing untrusted third-party code.
  • Pragmatism Wins: The best results come from simple tactics, like selling basic automations to local businesses, fine-tuning local models, and writing hard rules to stop agent hallucinations.