LonelyInvestorX

先验证需求, 再扩功能. 真正省下的不是开发时间, 而是避免为没人要的东西持续投入和优化. x.com/GoSailGlobal/s…

@chatcutapp Editability is the key: AI can accelerate the first cut without trapping editors inside a one-shot generated video.

Codex (ChatGPT) + ChatCut is a new level of AI-assisted video editing. The plugin gives GPT 5.6 a full NLE it can drive natively: - Talking head editing from transcripts - Timeline editing on real tracks - Stunning, consistent, editable motion graphics - Video generation with Seedance 2.0, plus music, voiceover, and sound effects Editing costs nothing beyond your own GPT tokens. ChatCut credits only kick in for generative assets like Seedance. More details below👇

@akshay_pachaar The hardest part is the stopping rule: a loop is autonomous only when success can be judged without another human prompt.

the four types of agent loops. loop engineering keeps getting talked about as one thing. it's actually a choice between four structures, and each one fits a different kind of task. it means designing the system that steers the agent, instead of steering it yourself move by move. that system always answers two questions. what starts a run, and what decides the work is done. in a hand-run session you answer both yourself, every single time. each loop type moves more of that into the system. here's each type, what triggers it, and when to reach for it. 1) turn-based. triggered by a user prompt. the agent gathers context, acts, and checks its work inside a single turn, then a human reviews the output and writes the next prompt. use this when requirements are still forming and every output changes what you'd ask for next. 2) goal-based. triggered by a /goal command carrying success criteria and a budget, like "get the homepage Lighthouse score to 90, stop after 5 tries." when the agent tries to stop, an evaluator model checks whether the goal is met, and a no sends it back to work. use this when the outcome is measurable but the path there isn't worth your attention. 3) time-based. triggered by a clock. an interval fires, the agent runs a fixed prompt like "check the PR, fix CI," then waits for the next tick. /loop runs on your machine, /schedule moves it to the cloud so it survives a closed laptop. use this for recurring work where the task is known in advance and only the timing repeats. 4) proactive. triggered by an event or schedule with no human present. a routine watches a channel, and when something needs handling it spawns a workflow with a triage agent, a fix agent, and a reviewer that adversarially judges the work before the task closes. use this for standing responsibilities where you can't predict what will come in, only that something will. each type hands off one more job than the last. turn-based keeps both with the human, goal-based automates the checking, time-based automates the trigger, and proactive automates both while deciding the workflow shape at runtime. so the mapping question isn't which loop is most advanced. it's whether your task is exploratory, measurable, recurring, or standing. the more you hand off, the less you babysit. I wrote the full breakdown on loop engineering. the article is quoted below.

@GoSailGlobal 把‘3天没人进就放弃’写成规则很关键，它让验证从感觉变成纪律，也能及时切断沉没成本，避免越做越舍不得停。

我就花过一个月做了个菜谱网站 结果无人问津 现在我会： 1️⃣ 花费几天调研好需求 2️⃣ 花费一天做个demo，做个waitlist 3️⃣ 然后开始宣传，看是否有用户进来，3天没有则下一个

Agent memory 真正的分水岭，不是能不能记住，而是什么时候写、写成什么结构、什么时候在后台重整。\n\n多数人只看到了 store。真正决定效果的，是记忆的压缩、提炼和持续演化。

@9hills 这类 provider 抽象一旦统一，模型切换就从迁移成本问题变成预算调度问题了。对重度 AI Coding 用户来说，这个层的价值往往比单次模型价格更关键。

不错，1 美元。然后我反手就是一个 pi install pi-commandcode-provider 在 Pi 里面用，美滋滋。 1 美元 = 10 刀（DeepSeek-V4-Pro 可以用 40 刀）

@MinLiBuilds Memory 这块最容易被低估的不是存下来，而是何时写入、怎么压缩、以及后台持续整理。真正能拉开差距的 agent，记忆一定是会演化的，不只是挂个 store。

Anthropic的工程师Kevin的一个分享。 价值$1000 刀，关于agent memory的workshop。 这将是 AI memory的主流，提前一年了解它，成为记忆专家。 非常值得看的一个短视频，以下是视频中的实操： 03:31 证明 AI 多个对话间没记忆（对照实验） 06:20 介绍 memory store，可以作为 AI 的记忆外挂 08:44 将 Memory Store 挂载给会话，实现跨对话记忆 15:36 执行 Dream，让 AI 在后台整理记忆并扩写简陋笔记 19:45 展示 dream，记忆变成了结构化 看完这个视频，接着阅读下面的这篇文章。 你将充分了解与 AI agent 一问一答背后，记忆的原理，以及最强省 token 的心法。

@vista8 先别急着把整套能力一次性开出来。把通用层、适配器接口、你自己写的 UI/流程先拆出去，跟任何可能有版权、商标、截图争议的部分彻底隔离，风险会小很多。

x.com/9hills/status/… 模型会收敛, prompt 会复制, 但 research, plan, verify, tooling 组成的闭环一旦跑顺, 差距就不是一句提示词能补上的 . 这类项目表面在卖 skill, 底层其实在争夺默认工作方式.

@9hills 我觉得这类项目真正值得抄的不是某个 skill, 而是把 research, plan, execute, verify 串成闭环的方式. 单点 prompt 很快会同质化, 工作流层才会形成长期差异。

大家怎么看 superpowers、gsd、gstack、openspec 这些专注于 Coding Workflow 的项目？ 我会从中汲取一些 有用的 skill，组成自己的 Research、Design、Plan、Develop、Test、Commit 工作流。

@gdb Yes. The product is not just the model output, it is the loop: context, permissions, feedback, and visible progress. Agents feel great when they reduce coordination cost, not just typing cost.

agents make for a surprisingly great product

@pengchujin 因为大多数协作对象要的不是轻量编辑器, 而是所见即所得, 批注修订, 还有组织模板. Markdown 赢在创作效率, Word 赢在组织流程。

markdown 这么简单好用，为啥绝大部分人工作还是用 Word。

x.com/FuSheng_0306/s… 不是谁在所有场景都更强，而是谁的系统更适合你当前任务 。 同一台电脑写同一个 app，比出来的往往是默认工具接入、验证习惯、长任务稳定性 。 这类比较最容易错在把“模型能力”和“工作流能力”混成一件事。

@FuSheng_0306 我感觉差异更多出在任务形态和工作流，不是单次同题的绝对强弱。长链验证、并行代理、浏览器/工具接入做得好时 Codex 会更占优；纯局部编码手感上，很多人确实会更偏 Claude Code。

讨教一下：为什么很多人说codex+gpt 5.5比claude code+opus4.7强了？这两天我用两个在同一个电脑上写同一个健康app，我还是觉得claude code比codex强很多啊！

@vikingmute 这个提示词本质上是在把“自信”强行翻译成“验证预算”。好用的点不只是 self awareness，而是它会逼模型持续暴露未验证假设，再自己补验证闭环。

这个 Codex 5.5 的 hack，非常有意思： 提示词是：“你对当前实现 100% 有信心吗？如果没有，请找出所有可能的漏洞，提出合适的修复方案，然后不断重复这个循环，直到你对新实现在事实上达到 100% 自信为止。” 作者说：Codex 5.5 是我见过唯一具备真正 self awareness 的模型，它绝不会轻易做出高自信的断言，除非它真正把所有事情都验证过。 但是对 Opus 4.7 完全无效，因为这个货多轮只会输出 “you're absolutely right” 这样的奉承话。 我当前就是用一个小型的项目来试试看，确实不错，之后可以用大项目试试看，看看是不是像作者说的这样。

@pengchujin 对，关键不只是“能读登录态页面”，而是把授权边界和后台并行都做顺了。这样更像是在借你的浏览器上下文工作，而不是粗暴 remote control。

Codex 能直接操作 Chrome 浏览器了，试了下好强。 - Chrome 扩展 + Codex 插件，Codex 可以在需要登录态的网站里读页面/执行任务 - 能在后台跨多个标签页并行，不接管你当前浏览，不影响自己使用 - 每个网站访问需要授权，可管理 - 填表、上传下载、敏感动作前会停下来让你确认

x.com/FredaDuan/stat… Bears focus on token compression. Bulls focus on workflow expansion. The real metric is cost per useful autonomy. Once that falls, demand scales faster than token optimization can shrink revenue.

@HiTw93 这个 /hunt 规则很关键: 在能用一句话说清根因之前不碰代码, 本质上是在强制模型先缩小搜索空间。很多 agent 失败不是不会改, 而是还没完成诊断就开始补丁式乱试。

终于到了 Waza SKill 设计思路的第 4 部分，讲完这个就差不多了，因为其他两个是 /read 和 /learn 之前已经简单聊过，这次继续聊工程师技能部分的 /hunt 技能，其实就是 debug 问题排查问题的技能。 其实证明 AICoding 是民科和专科的一个很大区别，可以来看用户是如何用 AI 来解决一些很久没有解决的问题的排查思路的，这个过程可以看到明显区别，其实这也是经验丰富的工程师其实用好AI远会比不那么懂技术的人可以解决更加复杂问题的原因。 之前经常碰到，Claude Code 遇到一个问题去解决，基本上就是是一个patch，你说不行，他给你是另外一个，你会发现4-5轮下面，又有新问题出来了，也即很容易出现在没有诊断出问题下不断去打补丁，很像之前没有AI时候刚刚写代码的小伙伴。 /hunt 的核心规则有意思，就是在 AI 能用一句话说出根因之前，不许碰代码。而且这句话有精度要求，需要明确的那种原因说明。 然后我设计了一张“自我欺骗检查表”，防止模型陷入几种典型的自我合理化的思维，每一种都配备了对应的规则，然后在 gotchas 里有真实案例，这里会根据我最近一个月排查问题时候出现的问题再次总结抽象一下。 假设验证阶段也有一些干活要求，比如加一个最新的观测手段，比如让AI学会打log，打断言，或者跑一个最小失败的测试case，修完之后还有问题应该是立马去更换方案，会把查了什么、排查了什么方向、还不知道什么整理成handoff交给用户来决定怎么继续，而非一直试下去。 输出也会建议到AI，根因在哪 file:line、改了什么 file:line、什么证据确认修好了、测试通过情况。最终状态三选一：resolved、resolved with caveats、blocked。 这样你会发现 /hunt 就很像一个经验丰富的技术专家了，遇到问题不是去猜，而是先沉下心去看问题在哪儿，诊断清楚原因，然后一把就过就解决的那种，往往这样会节约很多时间。 哈哈，假如你还有更好的 debug 方法，欢迎也告诉我，或者给 pr github.com/tw93/waza

@shannholmberg This is the real unlock: separating memory from repo context. Once knowledge becomes a portable retrieval layer, every new project starts with prior decisions, voice, and constraints instead of relearning them from scratch.

I connected my knowledge base to every project I work on. every agent reads my wiki before doing anything I built a knowledge base in obsidian with 230+ pages. my tweets, bookmarks, articles, ideas, notes, all compiled into structured wiki pages with cross-references the knowledge only worked when I was inside that folder. if I started a new project or opened a different codebase, the agent had no idea what I know or how I think so I set up qmd (by tobi lutke) to index the wiki. hybrid BM25 + vector search with LLM re-ranking, runs locally. then I wrote a global skill that any agent in any project can call now before an agent starts brainstorming, planning, or writing, it searches my entire knowledge base first. voice rules, content performance data, frameworks, past thinking on the topic 1. agent in any project calls /knowledge-shann "topic" 2. qmd hybrid-searches 230+ wiki pages 3. returns relevant concept pages, source summaries, and metrics 4. agent reads brand foundation (banned AI words, visual style, voice rules) 5. agent starts working with that context loaded the same pattern works for company knowledge bases too. /knowledge-espressio for agency knowledge, /knowledge-lunar for client work. different collections, same architecture the whole knowledge layer is just markdown files indexed by qmd. one CLI command, plain text back. token efficient and works with any agent that can run bash

@FredaDuan The key metric is shifting from cost per token to cost per completed workflow. Once routing, caching, and loop pruning make agentic work predictable, budgets stop looking like experimentation spend and start looking like operating leverage.

There's a growing narrative that AI token consumption is too expensive and too wasteful. Engineers are "tokenmaxxing." CFOs are nervous. Budgets are blown. The concern isn't wrong. There is waste. But it misses the structural picture. The Mental Model AI spend = users × tasks/user × tokens/task × $/token The first half — users and tasks per user — is ripping. Claude Code's adoption curve is steeper than Cursor's was at the same stage. Cowork is ramping faster than Claude Code. We're barely scratching the surface. The tension lives in the second half: tokens/task and $/token. That's where optimization happens, and where the real debate gets heated. Two Levers 1. Same work, cheaper tokens. Model routing is the highest-impact play. A routing layer that sends trivial tasks to Haiku and reserves Opus for complex reasoning can cut 60-80% of spend on eligible tasks. OSS models for commodity tasks — self-hosting Llama or Qwen for boilerplate — means zero per-token cost, swapped for GPU capex. Or the simplest strategy: wait. Token prices fall roughly 10x every 18 months. 2. Same work, fewer tokens. Prompt caching is low-hanging fruit — cache repeated system prompts, reads cost 10% of input price. Context window management — summarize history instead of re-sending full conversations. Thinking budget tuning — cap thinking tokens for simple completions, uncap for hard problems. And agent loop pruning, possibly the biggest single source of waste: most agents waste 50-70% of their tokens on redundant tool calls, retries, and pointless sub-agent spawns. Who Optimizes What Every layer of the stack targets different metrics. Infra ( $NVIDIA, $Cerebras, $Groq) optimizes tokens/watt and tokens/dollar. Model providers ( $Anthropic, $OpenAI, $Google) optimize quality/token and thinking efficiency. App layer (Cursor, Claude Code, Codex) optimizes cost/task and cache hit rates. Enterprise buyers optimize cost/engineer and ROI vs. headcount. Each layer's gains pressure the layers around it. Faster hardware forces providers to compete on price. Better models reduce the tokens apps need. Application routing erodes premium pricing. Enterprise CFOs demand all of the above. Bear vs. Bull The core question: does optimization compress AI revenue faster than new demand replaces it? The bear case is real. Rationalization is the CFO's first instinct — when the budget blows, the reaction is "finally back inside the envelope," not "let's 10x usage." Model routing drops revenue per task 10-20x. OSS is closing the gap fast. Caching is pure token destruction: cache hit = zero revenue, no new demand generated. And thinking efficiency is self-cannibalization — if Anthropic improves extended thinking by 3x, billing for the same reasoning task drops by two-thirds. The bull case is equally compelling. Current usage is cost-constrained, not demand-constrained. Companies blew their budgets and had to throttle. Drop costs 5x and every killed use case comes back. Today only coding is at scale — testing, documentation, code review, security auditing are all waiting for the economics. Penetration is still single digits. Agentic workflows are a token multiplier: a human-in-the-loop conversation runs thousands of tokens, an autonomous agent on a complex task runs hundreds of thousands. New modalities — vision, audio, video — are net-new demand that dwarfs text. And Jensen Huang's framing: a $500K/year engineer should consume at least $250K/year in tokens. At $5K, you're dramatically under-leveraging AI. Where This Lands The optimizers will win every individual battle. Every caching trick, every routing layer, every pruned agent loop will work. Cost per task will drop dramatically. But the number of tasks, the number of users, and the complexity of what gets delegated to AI will grow faster than efficiency compresses spend. Token costs are going down. Token spend is going up. Both things are true, and they aren't in contradiction. Full: open.substack.com/pub/robonomics…