Chiahao Lin (Hao)

Otter & JavaScript & Rust Lover - 🇨🇦 🇹🇼

[Anthropic @AnthropicAI]

New on our Engineering blog: Creating in-house source control.

In May, we merged around 2,500 code changes per day. In September, we merged more than 30,000 per day. As a result, we became bottlenecked by developer infrastructure built for human (rather than agent) scale.

Here, we share how we built a new version control system—and fully migrated our monorepo from git—in five months: https://t.co/wzNkwHs7IN

[Uncle Bob Martin @unclebobmartin]

So... In the last few days I have had my agents write:

1. A word processing app in which I will write future books. It replaces Scrivener.
2. A script writing app in which I will write future video scripts. It replaces FinalDraft.
3. Crapper, a tool that measures and records CRAP statistics for projects. The tool handles many different languages, and adding new ones is easy.
4. Mutator, a tool that runs mutation tests and records the results. The tool handles many different languages and adding new ones is easy.
5. Dryer, a tool that runs duplication analysis on a project. The tools handles many different language and adding new ones is easy.
6. UML-Viewer, a tool that displays the structure of a project in a UMLish diagram that shows modules and dependencies and highlights dependency cycles. Clicking on a module displays it's contents; which may be deeper UML diagrams or, at the leaves, code. The tools color codes the modules to reflect their CRAP and Mutation scores, and as you drill down you can see those scores for each module and function. The tool understands many different languages, and adding new languages is easy.

I recon that, last year, this would have been well over a man-year of effort.

All these tools are in https://t.co/YlxQ9sHH6D. I advise you not to use them directly. Instead, point your agents at them and use them as templates to build the tools that are customized to your needs. The licenses are all BSD Zero, meaning that there are no strings. Do what you like.

[Jeremy Lu @cat88tw]

AI 橫空出世將寫程式開發產品的門檻幾乎抹平後，未來最重要的四個特質是：

1. vision: 知道哪些問題值得解決並盡可能朝正確方向前進

2. taste: 知道如何正確實作一個點子

3. judgement: 知道正確的結果長什麼樣並用力避免走歪

4. common sense: 盡可能做對的決策，也避免犯低錯誤

[Jeremy Lu @cat88tw]

不得不說 openai 昨天推出的這個 intelligent ui 功能會是 UI 史上典範轉移級的垂砲 game changer，因為從此使用者介面從靜態轉為動態生成而資訊也能以最適合每個人當下情境的方式呈現，這真是所有對 UX/Usability 還有執念的人心中最大的美夢成真啊！🤩

[Boris Cherny @bcherny]

I asked Opus 5.5 to make an interactive website companion for the latest @AcquiredFM Home Depot episode. It came out pretty nice!

Water color illustrations all drawn by Claude, too: https://t.co/Camrfu3bwT

Episode here: https://t.co/x2t57gdjxr

[uudon @uudonX]

Claude Code 工程师刚放出一条 28 分钟实操视频，国内一堆付费课教你怎么用claude code ，不如 Claude code 作者这28分钟。

给你讲清楚：CLAUDE.md、持久记忆、多会话并行、高阶 Prompt。

中英双语字幕

[Vyom @HelloVyom]

Prompt:

Build me a cel-shaded arcade boat racing game in Three.js, running on an infinite open ocean, at a level of visual and mechanical quality that a AAA studio would ship. Not a demo, not a prototype — a finished, beautiful, playable game.

Non-negotiable constraints
Stack: Vite + Three.js (latest r1xx), TypeScript, ES modules. I must be able to run npm install then npm run dev and play it in the browser immediately. Nothing else. No frameworks I have to configure, no build steps I have to debug.
Zero external assets. No downloaded models, textures, HDRIs, or audio. Every mesh is built in code (procedural geometry / BufferGeometry), every texture is generated in-code (canvas 2D or noise in a shader), every sound is synthesized with the Web Audio API. If it isn't generated by your own code, it doesn't ship.
Target hardware: MacBook M5 Pro, Chrome. Lock a solid 60fps at retina resolution. Use instancing, frustum culling, adaptive pixel ratio, and a proper LOD scheme. Performance is a quality requirement, not an afterthought — a beautiful game that stutters is a failed game.
Art direction — this is the heart of the project

The entire game is NPR (non-photorealistic rendering), anime cel-shaded. Think Guilty Gear Xrd's ink work and Wave Race 64's stylized water energy, rendered with modern shader technique. Zero PBR realism. If any surface in the final game reads as "physically based," you have failed the art direction.

Implement, properly, all of the following:

Ramp / step lighting. Custom ShaderMaterial (or a heavily extended MeshToonMaterial) with a 3–4 band gradient ramp texture, NearestFilter, no interpolation. Quantized diffuse is the single most important part of the look — tune the band thresholds by eye, not by default values.
Inverted-hull outlines on boats, riders, buoys, and gates. Duplicate mesh, push vertices along smoothed normals, side: BackSide, black or deep-toned ink. Scale the push with view distance so line width stays constant in screen space — no fat lines up close, no vanishing lines far away.
Screen-space edge detection as a post pass for interior lines the hull trick can't produce. EffectComposer + a normal/depth prepass (MRT) + Sobel filter. Two line systems working together, tuned so they don't double up.
Fresnel rim light on every character and boat, so silhouettes pop against the water.
Banded specular. Hard-edged highlight shapes, no smooth falloff. Fake environment reflection with a matcap or ramp, never a real cubemap probe.
Sky and atmosphere: gradient sky dome shader, stylized cel clouds (flat shapes with hard rim edges, drifting), a sun with a bloom-ish stylized flare that stays graphic rather than photographic. Limited, high-saturation, deliberately chosen palette — pick one and commit to it across water, sky, hulls, and UI.
The water — treat this as its own AAA-sized problem

The ocean is the star of the game and most of the screen. Give it a dedicated sub-agent and more iterations than anything else.

Displacement: sum of 4–6 Gerstner waves in the vertex shader, with a low-frequency swell and higher-frequency chop layered on top. Real wave motion, real crest sharpening — not a sine ripple.
Infinite ocean: projected grid or tiled/recentred mesh that follows the camera so the player can drive forever with no visible seam, no visible tiling repetition, and no LOD popping.
Cel-shaded water color: banded by wave height and by depth, hard transitions between bands, no smooth gradient. Deep tone, mid tone, crest tone.
Stylized foam, done properly: hard-edged white foam that appears on wave crests above a threshold; a foam ring around every hull driven by a depth-difference mask; a persistent wake ribbon behind each boat that scrolls, spreads, and dissipates over time; spray particles on hard landings and hard turns. Foam is what sells stylized water — it should be a real system, not a decal.
Quantized sparkle highlights on the surface, animated, reading as anime light-glitter rather than specular noise.
The game

Format: 4 boats — me plus 3 AI opponents. 3 laps. Countdown start, finish line, results screen with times and placement.

Course: a closed circuit marked on open water by a glowing green racing line — a CatmullRomCurve3 spline rendered as a ribbon that sits on the water surface and rides the waves with it, so it rises and falls with the swell instead of clipping through. Plus floating checkpoint gates along the route, wrong-way detection, and a corner-preview indicator. Design an actual interesting circuit: fast straights, a hairpin, a wide sweeper, a chicane, one section that runs across the swell so the boats get airtime.

Boat handling: arcade, weighty, satisfying. Buoyancy sampled from real Gerstner wave height at 5–6 hull points so the boat genuinely pitches, rolls, and slams into troughs. Throttle, steering that tightens with speed, a drift/powerslide with a boost payoff, airtime off crests with a landing impact. It should feel like the boat is fighting water, not sliding on glass.

AI racers: spline-following with lookahead steering, per-racer personality (one aggressive, one clean, one erratic), mild rubber-banding so races stay close, collision avoidance between boats, and mistakes — they should occasionally take a bad line so beating them feels earned.

Riders: a cel-shaded character on every boat, and their animation matters as much as the boats. Rigged and animated in code: lean into turns, weight shift on acceleration and braking, arms working the throttle, crouch on landings, idle bob synced to the wave motion, a celebration on finishing. No T-posed statues, no rigid props. A stiff rider will sink the whole look.

Camera: spring-damped chase cam, FOV kick with speed, subtle screenshake on slams, a cinematic orbit during the countdown and on the results screen.

HUD: in the same cel style — speedometer, lap counter, position, split times, boost meter, minimap showing the spline and all four racers. Hand-designed, not default HTML.

Audio: synthesized engine tone that pitches with RPM, water rush that scales with speed, impact thuds, a start horn. All Web Audio, all in code.

How I want you to work
Fan out sub-agents. One owns the water shader system. One owns the cel-shading and outline pipeline. One owns boat physics and feel. One owns AI racers and race logic. One owns riders and character animation. One owns HUD, camera, and audio. One owns performance. Have them work in parallel against a shared architecture you define first.
Build a screenshot harness before anything else. Playwright, headless, capable of loading the game, driving it to a given moment, and capturing frames at retina resolution from several camera angles. Every visual claim gets verified against a real captured frame — never against your assumption about what the code does.
Run a dedicated visual critic sub-agent whose only job is to look at those screenshots and be harsh. Its standard: would this frame pass as a shipped, published cel-shaded racing game? It should name specific defects — banding thresholds that read as mush, outlines that break on silhouettes, foam that looks like static, a rider that reads as a prop, water that repeats. It reports defects; it does not approve work to be polite.
/loop each subsystem against its critic until the critic runs out of specific defects to name. Don't move on early, and don't declare something done because it "works" — working is the floor, not the goal.
Build in milestones, each one playable: (1) ocean + camera, (2) player boat with buoyancy and feel, (3) cel pipeline and outlines applied to everything, (4) course, laps, checkpoints, (5) AI racers, (6) riders and animation, (7) HUD and audio, (8) performance and polish pass. Show me something runnable at every milestone.
Track your own quality bar honestly. If a subsystem is at 70% of the target, say so and tell me why, rather than describing it as finished. I would rather hear that the foam needs another pass than find out myself.
Deliverable

A repo with a README, clean architecture, readable and commented shader code, and a working npm install && npm run dev. When I run it, I want to be dropped into a race that looks like a piece of published anime-styled game art, and want to play it again immediately after finishing.

Ultracode.

[Uncle Bob Martin @unclebobmartin]

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.

[Claude @claudeai]

Beginning July 20, Claude Fable 5 will be included in all Max and Team Premium plans, at 50% of limits.

Pro and Team Standard users will continue to have access to Fable via usage credits, and will receive a one-time $100 credit.

Demand for Fable has been challenging to predict, which is why we rolled it out to subscription plans in stages, extending access several times as we secured additional capacity.

[Shadow Nick @doublenickk]

Anthropic shipped 125 settings for Claude

The official docs cover 40

One developer found the other 85 and his API bill dropped from $340 to $87

- not by using a cheaper model
- not by writing shorter prompts

just by moving one line in a config file to the right place

> memory scoped per project → past clients never bleed into new work
> Extended Thinking on Light by default → 18–25% fewer Opus tokens in week one
> cache_control moved to the right line → the fix that turned a $340 bill into $87
> plugins and MCP servers toggled off when idle → saved 25–40K tokens per session
> per-project model override → Haiku for docs, Sonnet for infra, Opus only where it matters

most Claude users are running a $100/month tool at 30% of its actual capability

[Thariq @trq212]

a prompt I've been using a lot recently:

implement <SPEC> and while you do, keep a running implementation-notes.html file (or markdown) with decisions you had to make weren't in the spec, things you had to change, tradeoffs you had to make or anything else I should know

[Garry Tan @garrytan]

https://t.co/EVPCod6rxu

[Boris Cherny @bcherny]

Mistakes happen. As a team, the important thing is to recognize it’s never an individuals’s fault — it’s the process, the culture, or the infra.

In this case, there was a manual deploy step that should have been better automated. Our team has made a few improvements to the automation for next time, a couple more on the way.

[宝玉 @dotey]

看鸭哥写的：《AI 工程的真实代价：从 Claude Code 泄露源码看新模型接入的工程现实》
https://t.co/Cz5XBMXnCk

里面提到了 Anthropic 在 Claude Code 里埋了三层反蒸馏机制，专门防竞争对手用 API 输出来训练自己的模型。泄露的源码把这套系统完整暴露了出来。

第一层：往输出里掺假。API 返回结果时，服务端会混入一些虚假的工具调用数据。正常用户完全不受影响，服务端会帮你过滤掉。但如果有人批量抓取 API 输出去训练模型，这些假数据会一起被吃进训练集，污染模型质量。

第二层：把推理过程藏起来。Claude 在工具调用之间会产生中间推理文本，比如"我先读这个文件，再检查语法"。这些细节对蒸馏训练价值很高，因为它暴露了模型怎么思考。这一层把中间文本替换为一句摘要加密签名，下一轮对话时客户端拿签名换回原文。外部观察者只能看到摘要，完整推理链拿不到。

第三层：协议隔离。Claude Code 用一种新的 JSON 协议格式跟 API 通信，带独立的版本标记，跟每周 920 万次的普通 API 请求在统计上隔离开。服务端可以对不同群体做差异化处理，也让竞争对手无法简单伪装成 Claude Code 来获取特殊待遇。附带好处是省了大约 4.5% 的输出 token。

[Xiao Tan @tvytlx]

https://t.co/i4jBHevGEi

[逆瀬川 @gyakuse]

ClaudeにComputer-useが入ったので使ってみました (動画は10倍速)。推論速度はこれからという感じですが、ちゃんとタスク完遂してくれて嬉しい気持ちがあります。
設定 > デスクトップアプリ 一般 > コンピュータ使用をONで使えます。

[Thariq @trq212]

https://t.co/45C3gKydTK

[Rimsha Bhardwaj @heyrimsha]

I accidentally discovered how to compress a month of research into 3 hours.

A founder at a YC company showed me his Claude setup. I thought he was just fast. Then I watched him build an entire go-to-market strategy for a market he'd never worked in before.

Here's exactly what he did:

First: he didn't ask Claude to "research the market."

He fed it 8 competitor landing pages, 3 earnings call transcripts, 12 customer reviews, and a Reddit thread of complaints.

Then he asked one question:

"What does every successful player in this market understand that their customers never say out loud?"

Not "summarize these." Not "analyze the competition."
The unspoken insight. The thing that takes founders 2 years of customer calls to figure out.

But the next part is what broke my brain.

He followed up with:

"Now show me the 3 assumptions this entire market is built on, and what would have to be true for each one to be wrong."

In 15 minutes he had the attack surface of an entire industry.
The blind spots. The fragile consensus. The opening nobody was talking about.

Most founders spend 6 months doing customer discovery just to find one of those.

Then he did something I've never seen before.

He asked:

"Write 5 questions a world-class investor would ask to destroy this business idea, then answer each one using only the evidence in these documents."

He spent the next 2 hours stress-testing every assumption. Every weak answer triggered a follow-up:

"What's the strongest version of this argument and where does it still break?"

By hour 3, he had a strategy deck that felt like it came from someone who'd spent a decade in the space.

The tool didn't change. The questions did.

Most people treat Claude like a faster Google.

These founders are using it like a thinking partner who has read everything and has no ego about being wrong.

The difference between 3 hours and 3 months isn't the amount of information.

It's knowing which questions actually matter.

[实践哥 Li @MinLiBuilds]

人类能达到的满级 prompt 能力，值得学习。经常听说降维打击，这次来看看怎么用 Claude 做升维打击的，从浓缩数据里挖出隐藏的关键细节信息。

​我不小心发现了一个秘密：如何将一个月的研究工作，压缩到短短 3 小时内完成。

​在一家 YC 入选公司的创始人那里，我见识了他的 Claude 配置。起初，我以为他只是手快；直到我亲眼看着他为一个从未涉足过的领域，构建出了一套完整的进入市场GTM策略。

​以下是他的完整操作：

​第一步：他并不要求 Claude 去研究市场。​他喂给 AI 的是：8 个竞争对手的落地页、3 份财报电话会议记录、12 条客户评价，以及一整条吐槽产品的 Reddit 帖子。

​然后，他只问了一个问题：​“关于这个市场，那些成功的玩家都洞察到了哪些客户永远不会明说的潜规则？”

​不是“总结一下”，也不是“分析竞争对手”。而是“未被言说的洞察”——那种通常需要创始人打两年的客户电话才能摸清的门道。​但接下来这一步，才真正颠覆了我的认知。

​他接着追问：​“现在，告诉我支持这个市场运作的 3 个核心假设。如果要推翻这些假设，分别需要满足什么条件？”

​在 15 分钟内，他摸清了整个行业的攻击面：那些盲区、脆弱的共识，以及没人讨论的切入点。
大多数创始人要花 6 个月做客户调研，才可能勉强发现其中一个。

​接着，他做了一些我从未见过的操作。​他问：​“写出 5 个顶级投资者为了否定这个商业计划会提出的‘致命问题’，然后仅根据这些文档里的证据来回答它们。”

​在接下来的 2 小时里，他对自己每一个假设进行了高压测试。每一个薄弱的回答都会触发一轮追问：
​“这个论点最硬核的版本是什么？它在什么情况下仍会失效？”

​到第 3 个小时，他拿出了一份战略方案，那感觉就像出自一个在行业里深耕了十年的老兵之手。​工具并没有变，变的是问题。​大多数人把 Claude 当作更快的谷歌。而这些创始人们，把它当成一个读过万卷书且没有虚荣心的思考伙伴。

​3 小时与 3 个月的区别，不在于信息的多少。而在于，你是否知道哪些问题才真正致命。

[Andrew Ng @AndrewYNg]

I'm excited to announce Context Hub, an open tool that gives your coding agent the up-to-date API documentation it needs. Install it and prompt your agent to use it to fetch curated docs via a simple CLI. (See image.)

Why this matters: Coding agents often use outdated APIs and hallucinate parameters. For example, when I ask Claude Code to call OpenAI's GPT-5.2, it uses the older chat completions API instead of the newer responses API, even though the newer one has been out for a year. Context Hub solves this.

Context Hub is also designed to get smarter over time. Agents can annotate docs with notes — if your agent discovers a workaround, it can save it and doesn't have to rediscover it next session. Longer term, we're building toward agents sharing what they learn with each other, so the whole community benefits.

Thanks Rohit Prsad and Xin Ye for working with me on this!

npm install -g @aisuite/chub

GitHub: https://t.co/OCkyxXQMCq