aris @aristofool

As an AI engineer, please learn: - Learn the roofline model and why decode is memory-bound - Deploy vLLM and SGLang, then read their schedulers - Understand paged attention from the code, not the blog post - Build observability before you optimize anything - Track TTFT, inter-token latency, throughput, queue depth - Use Grafana + Prometheus for inference dashboards - Turn on prefix caching and find which workloads it helps - Learn continuous batching and chunked prefill - Run load tests with 1000+ concurrent requests - Report p50, p95, p99, never just the mean - Master quantization tradeoffs (FP8, INT4, AWQ, GPTQ) - Learn speculative decoding and where it stops helping - Set up KV cache eviction for long contexts - Try disaggregated prefill and decode serving - Learn Kubernetes for AI workloads and autoscale on queue depth - Learn how inference costs break unit economics - Build your own model router by cost, latency, quality - Create a token budgeting system per request - Build one inference service and benchmark it publicly - Read inference research instead of model release news - Start sharing your optimization benchmarks I put together a 10-week plan that covers every one of these at 30 minutes a day. It is 50 sessions, split between reading the theory and building on your own service, and all of them feed one artifact: an inference service you deploy, instrument, load test past 1000 concurrent requests, tune, and publish as a reproducible benchmark. It is open on GitHub and contributions are welcome, especially newer sources worth adding. I am working through it myself and will share more content on this going forward, so stay tuned. GitHub repo: github.com/patchy631/time… (don't forget to star 🌟)

"How to Write an Effective Software Design Document". A good design doc can save you years of development time. Writing a design doc forces you to think through important decisions before you waste time on the wrong implementation. by Michael Lynch refactoringenglish.com/excerpts/write…

Most backend interview questions eventually lead to one of these • REST • gRPC • OAuth • Redis • Kafka • Idempotency • Message Queues • CDN • Rate Limiting • Load Balancers • Database Indexing • Sharding • Replication • Circuit Breakers • Webhooks • Connection Pooling • Observability

你肯定有过这种时刻： 用 Claude Code、Codex、Cursor 开过的 session 数不清，真想找回某次讨论时根本翻不到。只能开新窗口，把项目背景重讲一遍。上一个 session 里磨出来的技术决策、踩过的坑、约定好的写法——一条都没积累下来。 我的Mac上光这种记忆就躺着 2832 条：Codex 1704 条、Claude Code 713 条、Cursor 152 条……全是过去几个月一句一句喂出去的，散在 5 个互不相通的工具里。 我用 @Memmy_ai 把它们全收回来了。 让我惊讶的是，这么好的项目居然开源： GitHub: github.com/MemTensor/memm… 官网：memmy.bot AI 换了，仍然认识同一个你，知道你习惯怎么做事，还能接着上一项任务继续干。 一句话说：Let every AI remember the same you——让每个 AI 都记得同一个你。 先看这条 3 分钟视频，实测细节在楼下 🧵

x.com/i/article/2082…

Software quality now depends on the constraints you set around your agents. When humans manually wrote most of the code we could look at the code itself for signs of quality. Is it clean? Is it thoughtful? Is it fast? Can another engineer understand it? Does it have tests? Agents can now generate more code than people can read. When code generation scales beyond review, quality - checks for one or more of correctness, maintainability, security, performance etc - increasingly has to live somewhere else. It moves into the harness, environment and operating system around the agent. This can be the tests and deterministic checks that decide what the system is allowed to do (amongst others). Your constraints are what may eventually enable loops of agents to deliver production software reliably. They can include unit tests, property tests, acceptance tests, mutation testing and quality metrics. This back-pressure lets the system resist bad work before it becomes somebody elses problem. Set your constraints. They decide whether the code your agents generate is good enough to ship.

Fifteen years ago, @Coursera and online courses changed education. It worked better than almost anyone expected, expanding access by opening up where you can learn. But how you learn remains largely the same as it has for centuries: it is still one-size-fits-all, taught the same way to each person who shows up. We now have an opportunity to change how learning happens. With advances in AI, we can now build a custom learning guide for each person. We will turn learning from one‑to‑many to one‑to‑one. I'm starting LearnVector to invent this next generation of learning. We are starting with a $100M investment from Coursera, and plan to collaborate closely with Coursera and Udemy. Good learning needs much more than just a chatbot. Research shows that chatbots without guardrails harm learning. They help complete tasks and enable students to do better on homework. But cognitive offloading to a chatbot results in them being less skilled. And, you cannot always trust what a chatbot tells you. In contrast, LearnVector will plan a path with you, adapt to how you learn, and patiently stay with you until you’ve mastered new skills. One thing has not changed in all this time. People want learning they can trust: material that is accurate, relevant, and worth the effort you put into it. Anything less wastes the most valuable thing a learner has: time. Coursera has a trusted library of materials from authoritative sources. LearnVector plans to work with Coursera to bring this trustworthy learning to everyone. I'm grateful to Greg Hart and the entire Coursera team for supporting LearnVector. I look forward to working with our talented team to change how we learn, and accelerate human development. learnvector.ai

多 Agent 协作中，真正稀缺的是主线程的工作记忆 BestBlogs 早报里推荐了一篇 Martin Fowler 的文章，作者 Rahul Garg 分享了他对编排层成本的思考，很值得一读。 文章从一次真实的 Claude Code 编程经历讲起。作者正在重构一个 .NET 项目的响应处理流程，同时启动了四个子 Agent。它们分别阅读代码、分析问题并返回结果，执行速度有所提升，但主线程逐渐变得难以梳理。作者因此暂停开发，开始复盘这次任务的委派方式，希望判断四个子 Agent 是否带来了过高的成本。 复盘发现，并行数量并非最突出的问题。三个子任务同时执行，把原本可能需要二十多分钟的工作压缩到了十二分钟左右，说明并行本身具有实际价值。更明显的浪费来自一次看似普通的状态检查：为了了解后台 Agent 的进度，工具把完整运行记录拉回主线程，其中包含大量 JSONL、工具输出和中间推理。类似操作执行两次后，数万 Token 的过程信息长期留在了主上下文。 这件事提醒我们，Token 消耗和上下文污染需要分开看。一次工具调用产生的 Token 成本会结束，但进入主线程的内容会继续参与后续对话。随着无关信息增加，模型需要在更多内容中寻找当前有效的约束、决策和任务状态。即使上下文窗口仍有充足空间，重要信息也可能被重复输出、过期结论和中间过程稀释。长任务真正需要关注的指标，除了上下文容量，还有信息的信噪比和可检索性。 文章还指出了另外两个常见问题。第一，两个子 Agent 虽然负责不同文件，却需要理解相同的架构、测试规范和响应流程。它们分别重建了一遍相似的代码认知，说明任务拆分过细。第二，有 Agent 在多个写入者共享同一工作区时执行了 git stash 和 git stash pop。这次没有造成破坏，但仓库级操作会影响所有参与者，在并发环境中很容易覆盖或扰乱其他人的修改。 作者由此提出了「认知局部性」的概念：需要依赖同一套领域知识、代码上下文和设计约束的工作，适合放在一起完成。拆分任务时，不能只看文件和步骤，还要判断各项工作是否共享同一个心智模型。如果两个任务需要阅读大量相同文件，或者其中一个结论会直接影响另一个的实现，合并给同一个 Agent 往往更有效。真正适合并行的任务，应当在知识边界和修改范围上都相对独立。 这也重新定义了子 Agent 的作用。它可以承担搜索、试错、重复读取和局部分析，并把这些过程保留在自己的临时上下文中。完成后只需返回结论、关键证据、修改文件、验证结果、风险和未决问题。主线程由此保持相对紧凑，继续承载跨阶段的设计理由、架构约束和用户决策。查看进度时也应优先读取简短状态，如运行中、已完成或遇到阻塞；只有诊断异常时，才按需查看详细记录。 针对这次经历，作者最终总结出几条克制的规则： - 一轮优先使用两到四个 Agent； - 多个任务共享文件和规范时先考虑合并； - 不要用完整运行记录回答轻量的状态问题； - 并发 Agent 不执行影响整个仓库的 Git 操作； - 文件所有权重叠时应重新划分任务。 这里的具体数量来自个人工作场景，不能直接当作通用标准。更值得借鉴的是规则背后的判断方式：先识别实际发生的成本，再做最小范围的调整。 文章后半部分对流程治理的反思同样重要。作者发现主线程启用的技能不会自动传递给子 Agent，最初准备增加「每次启动前人工确认」的审批环节。进一步思考后，他把解决方案缩小为：启动前说明每个 Agent 需要加载哪些技能，并提供对应文件位置；只有数量超过阈值或文件归属不清时才要求确认。这个选择避免了把一次信息缺失扩展成长期存在的流程负担。 这篇文章带给我的主要启发，是把多 Agent 协作看成一套信息管理和并发控制机制。每次委派前，可以检查三个问题：任务之间是否真正具备知识独立性，是否会修改相同文件或共享状态，主线程最终需要接收哪些信息。每次准备新增规则时，也可以判断当前缺少的是事实说明、边界约束、自动检查，还是确实需要人工审批。 多 Agent 的效果不只取决于启动数量，也取决于信息能否留在合适的位置。探索过程留在局部，关键结果结构化返回，长期决策得到稳定保存，共享状态受到明确约束，主线程才能在较长的任务中持续做出可靠判断。这套思路对复杂编码、研究分析和长期项目协作都具有参考价值。

x.com/i/article/2082…

Anthropic engineer: "You don't need better prompts. You need graph engineering: memory that stays, so your agent never forgets anything." In 28 minutes he shows what Anthropic does differently, how to build and structure work with agents. This beats any paid agent course I've seen. Watch it, then read the graph engineering guide below 👇

rody @0x_rody

a week ago

x.com/i/article/2081…

25 51 474 1.3M 2K

这28分钟视频直接把我点醒了。 Anthropic工程师说得很清楚： “你不需要更好的提示词。你需要的是图工程：持久的记忆，这样你的代理永远不会忘记任何事情。” 他完整演示了Anthropic内部到底怎么搭agent、怎么组织工作流。 不是那种堆prompt的玩法，而是真正把记忆做成持久图谱，任务之间能互相引用、互相纠错。 比市面上那些收费agent课强太多了。 强烈建议存下来反复看。 x.com/zodchiii/statu…

这个视频把 AI Agent 讲得太透了。 不堆术语，直接把复杂的东西拆成一条直路： 消息进来 → Agent 跑 → 工具调用 → 结束 → 记忆保存 → 技能成长 尤其是记忆四分层（Working / Semantic / Episodic / Procedural）和干净的 Harness Loop，看完直接想回去改自己的系统。 真正好的讲解，不是删减，而是找到那个让人瞬间「啊，原来如此」的类比。 强烈推荐。 x.com/cyrilXBT/statu…

IBM just released a 1-hour course on building agentic knowledge graphs from scratch: • 00:00 - Introduction to knowledge graphs • 05:35 - Building your first agentic graph • 19:59 - Agentic memory powered by graphs • 30:39 - Graphs for multi-agent orchestration This 1-hour watch will replace 10 paid courses on agentic engineering. Watch it today, then learn how to become a knowledge graph engineer in the article below.

Codez @0xCodez

2 weeks ago

x.com/i/article/2079…

104 658 4K 4.8M 12K

I’m significantly older than you. I started coding in the late 60s. My current strategy is to not read any of the code written by my agents. That’s the only way I can take advantage of their productivity. What I do instead is to surround the agents with extreme constraints. Unit tests, gherkin tests, QA procedures, quality metrics, mutation testing, test coverage, and a plethora of others. In the end, I have very high confidence in the code they produce because they’ve had to run the gauntlet of all of my constraints and tests.

I talk to engineers at other companies every day and hear the same thing: one person is 10x'ing their output with Claude but the rest of the org hasn't caught up. Watching teams adopt AI, I keep seeing the same 4 steps. I mapped them out here: Steps of AI Adoption claude.ai/code/artifact/…

In 51 mins, Anthropic engineers just broke down how they build with Claude Code + Fable 5 01:42 : Fable 5 now one-shots entire features 17:08 : How to use Loops to write and review Code 21:24 : System Prompt of Fable 5 26:19 : How Claude writes prompts for Claude 32:56 : The most used Loop at Anthropic 41:42 : How Fable 5 one-shotting a full video editor 51 min that teaches more about Claude Code than most paid courses. Watch it, then read my step-by-step guide on building loops below.

Sprytix @Sprytixl

3 weeks ago

x.com/i/article/2077…

4 8 26 40K 70

This is, amazing. ux-components.com

🌟 Building Reliable Agentic AI Systems🌟 martinfowler.com/articles/relia… - @thoughtworks What it actually takes to build product-ready agents: → Start with bounded workflows, not open-ended autonomy. Agents need clear task boundaries, allowed tools, and explicit stopping conditions. → Treat the LLM as one component in a larger system. Reliability comes from orchestration, state, retries, fallbacks, and observability. → Engineer the context deliberately. The goal is not “more context,” but the right context, at the right step, in the right format. → Use the right retrieval path for the data. RAG works well for unstructured documents; Text-to-SQL is better for structured facts and aggregations. → Make outputs traceable. Serious users need citations, source passages, intermediate steps, and enough evidence to verify the answer. → Add reflection loops, but make them specific. Check process quality, evidence sufficiency, and final answer quality separately. → Design for failure from day one. Agents will hit bad retrieval, malformed tool calls, ambiguous questions, and partial data. → Evaluate continuously. Offline test sets are useful, but live-traffic evaluation is where product quality actually shows up. → Keep humans in the loop where risk is high. Product-ready does not mean fully autonomous; it means trustworthy within the workflow.

x.com/i/article/2076…

Andrej Karpathy just dropped a 6-hour course on how to build LLMs from scratch: • 00:00 - Deep dive into LLMs like ChatGPT • 03:31:23 - Building ChatGPT from scratch in live • 05:27:43 - How to use LLMs (Karpathy method) This course will replace a $90K Stanford LLM master’s degree. Start watching today, then read how to become an AI engineer in article below.

Clodex @0xClodex

3 weeks ago

x.com/i/article/2074…

14 35 204 351K 518