1. [AINews] Qwen 3.8 Max(2.4T) and 27B, new open weights models for Coding and Cowork — AINews

  • Why read: A major open-weight release worth testing for coding agents, deployment costs, and model selection.
  • Summary: Qwen positions its 2.4T-parameter flagship for long-horizon coding, multimodal interaction, and operational workflows. Open weights give teams another model to evaluate, fine-tune, and run inside their own trust boundary. The operational claims are ambitious, so verify them with independent evals before making purchasing decisions. Add Qwen to task-specific coding and agent benchmarks, and measure cost, latency, reliability, and quality together.
  • Read more

2. The Inference Engineering Masterclass — Philip Kiely & Ali Taha, Baseten — Latent.Space

  • Why read: A practical guide to the engineering decisions that determine whether AI products work economically in production.
  • Summary: The conversation treats inference as its own optimization problem, rather than a final deployment step after training. It covers cache-aware routing, prefill/decode separation, quantization, speculative decoding, KV-cache movement, and parallelism. The same model weights can produce very different economics depending on how they are served. Make quality, latency, throughput, and cost explicit design constraints instead of defaulting to one model API.
  • Read more

3. The Disaggregation of Inference Compute. — Eugene Ng

  • Why read: Explains why inference infrastructure is becoming more specialized than simply putting models on GPUs.
  • Summary: Autoregressive decoding is sequential and memory-bound, unlike the highly parallel workloads used for training. The piece argues that using expensive HBM-heavy accelerators for every stage is becoming a blunt and costly approach. Separating prefill, decode, and memory tiers could reduce costs while improving utilization and latency. Expect infrastructure choices to vary more by workload as context lengths and agent loops grow.
  • Read more

4. Inference Will be the Largest Market in the History of Software — Luis Manrique

  • Why read: A useful way to think about turning model usage into a lasting product and operating advantage.
  • Summary: Inference demand grows with longer contexts, tool calls, retries, agents, evaluations, and user volume. That shifts the question from “which model is best?” to how each task should balance quality, latency, cost, security, and control. The valuable asset is a learning loop built from proprietary traces, feedback, evals, and workflow data, not simply access to a frontier model. Instrument AI usage now so deployed workflows improve instead of becoming recurring commodity API spend.
  • Read more

5. Emerging Markdown Formats That Shape Coding Agent Behavior — Bilgin Ibryam

  • Why read: A clear taxonomy for making repositories easier for coding agents to use correctly.
  • Summary: Agent-ready codebases need more than source code. They also need context, rules, procedures, plans, and domain knowledge. The piece separates standing guidance such as AGENTS.md from task-specific SKILL.md procedures, specs, plans, and task artifacts. Together, these form a “metacode” layer that helps agents turn intent into implementation. Move recurring tribal knowledge into versioned, scoped documentation, and keep tentative agent memory separate from team knowledge.
  • Read more

6. What nobody tells you about writing agent skills — PostHog

  • Why read: Practical lessons from running a large internal skill library.
  • Summary: PostHog’s main point is progressive disclosure: skills should direct agents to the right context instead of loading everything into every session. Names and descriptions should make selection easy; deeper references and scripts should load only when needed. Skills should also avoid becoming brittle, over-specified code. State the goal, constraints, and definition of done, then leave room for runtime judgment. Audit existing skills for discoverability, narrow scope, and clear completion criteria.
  • Read more

7. How Stripe Built their Knowledge AI Platform: A Company-Wide AI Agent on Deep Agents, Live in 1 Week — LangChain Blog

  • Why read: A useful case study in what company-wide agent adoption actually requires.
  • Summary: Stripe’s Kai connects to internal data, collaboration tools, and document systems. Its value comes from company context, governed access, and a broad skill library, rather than generic chat. The architecture separates the agent foundation, a Stripe-specific harness, configurable specialist agents, and the user interface. Before creating many one-off assistants, invest in shared platform controls and skills owned by the teams that understand the work.
  • Read more

8. The Economic Benefit of Refactoring — Giles Edwards-Alexander

  • Why read: Shows the token cost of poor codebase structure with a concrete refactoring experiment.
  • Summary: An agent-generated Rust data-access layer had grown into a 17,155-line file, increasing the context needed for routine changes. Incremental refactoring cut the estimated input-token cost of one representative task from 159,564 to 27,360. Modularity now affects human maintenance as well as the cost, speed, and reliability of agent work. Treat large, frequently used files as an operational liability and prioritize refactors that reduce repeated context costs.
  • Read more

9. How Agentic Coding Is Reshaping the Software Development Lifecycle — Abhi Agrawal

  • Why read: Explains where faster code generation moves the bottlenecks across the SDLC.
  • Summary: As code generation speeds up, planning, review, testing, security, CI/CD, and storage become the constraints. Poor prioritization can now create product sprawl faster, while manual review cannot keep pace with agent output. New workflows combine better specs, automated testing, and AI-assisted review. Redesign the pipeline around constrained, verifiable delivery instead of optimizing coding speed alone.
  • Read more

10. Agentic Coding: Bet on the Primitives — Robin Wieruch

  • Why read: Makes the case for owning flexible building blocks as implementation gets cheaper.
  • Summary: In a charting experiment, lower-level D3 primitives with React rendering outperformed a higher-level chart library once the design requirements became specific. The library handled the first 80% quickly, then created friction where differentiation mattered. Agentic coding makes custom components cheaper to build and maintain. Use primitives and composable foundations for strategically important product experiences; use abstractions when standardization provides the real benefit.
  • Read more

11. How to Recursively Improve Your Agents — Ashpreet Bedi

  • Why read: Presents a production-oriented way to improve agents from observed failures.
  • Summary: The proposed loop mines usage data for probes, runs them against the live agent, inspects logs, and updates instructions, tools, or parameters until the probes pass. The author separates this kind of optimization against a fixed specification from open-ended recursive self-improvement. The approach needs observability, safe testing, a way to apply changes, and real usage traces. Build evaluations around recurring failure modes and acceptance criteria, not broad benchmark scores alone.
  • Read more

12. Notes on incident response: — Slava Akhmechet

  • Why read: A concise operating model for handling technical and organizational incidents under pressure.
  • Summary: Incident response requires equanimity, rigor, and urgency, even though they can pull in different directions. Start by assessing impact and blast radius, then mitigate; do not begin with blame or an untested root cause. The recommended approach is breadth-first: generate hypotheses, delegate disconfirmation, and keep parallel work visible. This matters for agentic systems, where unexpected actions and dependencies make calm coordination part of reliability.
  • Read more

13. LLMs reward expertise — Sean Goedecke

  • Why read: Pushes back on the idea that stronger models make domain knowledge less useful.
  • Summary: Expertise improves prompting because experts spot wrong turns, identify useful details, and steer toward better questions. Terence Tao’s model interactions show how deep knowledge can make prompts shorter and responses more productive. Models can help people become broader generalists, but they do not define quality or interrogate answers for you. Use AI to amplify people with real system or domain context, and do not confuse fluent output with understanding.
  • Read more

14. Taste, Judgment and AI — Addy Osmani

  • Why read: Clarifies the human role when agents can generate and rank many plausible options.
  • Summary: Taste means recognizing quality in ambiguous situations; judgment means taking responsibility for a consequential choice. AI can propose, compare, and imitate options, but it does not bear the consequences of shipping one. Human judgment is therefore a governance responsibility, not merely a creative preference. Put review points around irreversible decisions, trade-offs, and named ownership instead of asking people to approve unlimited agent output.
  • Read more

15. Don’t be a meat proxy — gruhn.me

  • Why read: A useful standard for preserving trust when AI-generated text is everywhere.
  • Summary: Forwarding a model’s answer verbatim adds little value because the recipient can ask the model directly with their own context. The standard here is simple: read, understand, validate, and explain the result in your own words. That matters in code review, technical decisions, and stakeholder communication, where false confidence can spread faster than verification. Treat AI output as material for your judgment, not a replacement for accountability.
  • Read more

Themes from yesterday

  • Inference is becoming a core product and infrastructure discipline. Memory, routing, and workload-specific systems increasingly determine the economics.
  • Agentic coding moves the bottleneck from writing code to context, specifications, review, testing, and operational control.
  • Skills, repository guidance, evaluations, and real usage traces are becoming the foundation for reliable agents.
  • Human advantage increasingly lies in expertise, taste, judgment, and accountability.
  • Open-weight models are widening deployment choices, which makes task-level evaluation and proprietary learning loops more important.