Topic · 主题全部主题 →

AI 编码

AI 写代码的一切：编码助手、Vibe Coding、代码模型评测与开发工作流变革。

4,692条收录

553条精选

数据更新至 9月2日 02:30

精选归档 · 第 6 页

第 101–120 条 · 共 553 条

7月9日

星期四 · 5 条

22:30

AI at Meta@AIatMeta精选

AI 评分 65/100

Meta 发布 Muse Spark 1.1 模型Straight from @finkd — Muse Spark 1.1 is live.译来自 @finkd 的消息 - Muse Spark 1.1 已上线。

Mark Zuckerberg: （1）今天我们发布了 Muse Spark 1.1--一款价格极低但能力强大的智能体与编程模型。该模型已通过我们全新的 Meta Model API 以及 Meta AI 开放使用。

智能体 Meta 模型发布编码

另有 6 家信源报道

推荐理由：Muse Spark 1.1 主打 agent 和 coding 能力，同时压到极低价，这可能是 Meta 低价模型策略的正式开场。虽然这次没给具体数据，但后续模型、API 的布局值得关注。

15:16

IT之家（RSS）精选

AI 评分 77/100

官方支招两种AI方案：Claude Fable 5搭配Sonnet 5省token

Anthropic官方建议将Claude Fable 5用作规划层、Sonnet 5执行任务以降低成本。顾问模式下，Sonnet 5主执行，仅需额外指导时调用Fable 5；SWE-bench Pro测试显示相比完全用Fable 5可达92%性能，成本仅63%。协调者模式下，Fable 5充当规划者，将子任务分派给多个Sonnet 5工作智能体；BrowseComp基准上达到Fable 5单独运行96%表现，成本为46%。

Anthropic 教程/实践编码

另有 2 家信源报道

推荐理由：Anthropic 官方亲自下场教你省钱，把 Fable 5 当架构师、Sonnet 5 当码农，能保住九成以上性能同时省下近半成本，用 Claude 开发的人今天就可以在项目里试试。

04:08

OpenAI：官网动态（RSS · 排除企业/客户案例）精选

AI 评分 70/100

OpenAI 审计 SWE-Bench Pro 发现约 30% 的评测任务存在缺陷

OpenAI 对编码评测基准 SWE-Bench Pro 进行详细审计，发现约 30% 的任务存在缺陷。在 731 个任务的公开子集中，前沿模型通过率在八个月内从 23.3% 提升至 80.3%，但数据质量检查显示大量任务存在测试过于严格、提示词描述不足、测试覆盖不全或误导性提示等问题。OpenAI 建议模型开发者仔细审视评测结果，并指出 AI 智能体在规模化数据质量检查中日益增长的实用性。

OpenAI 编码论文/研究评测/基准

另有 2 家信源报道

推荐理由：OpenAI 自己审计了 SWE-Bench Pro，发现三成任务有缺陷，这个基准给出来的分数可能要打问号，做模型评测和选型的人该认真看看。

02:50

xAI：News（网页）精选

AI 评分 85/100

xAI 发布 Grok 4.5

xAI 今日推出 Grok 4.5，为其最强模型，专为编程、智能体任务和知识工作打造。模型训练于数万块 NVIDIA GB300 GPU，DeepSWE 1.0 得分 62.0%，DeepSWE 1.1 得分 53%，Terminal Bench 2.1 得分 83.3%，SWE Bench Pro 解决率 64.7%。服务速度 80 TPS，token 效率约为 Opus 4.8 (max) 的 4.2 倍，在 Harvey Legal Agent Benchmark 排名第一。定价 $2/百万输入 token、$6/百万输出 token。即日起在 Grok Build、Cursor 和 SpaceXAI API 可用，欧盟地区预计 7 月中旬上线。

智能体 xAI 推理模型发布

另有 7 家信源报道

推荐理由：Grok 4.5 在编码任务上追平第一梯队，但真正的杀手锏是极致性价比——输出成本只有对手的四分之一，还会倒逼编码模型继续降价。

01:22

ClaudeDevs@ClaudeDevs精选

AI 评分 73/100

Claude Code 的 Model 与 Effort：知道更多 vs. 更加努力http://x.com/i/article/2074606120292020224Model and effort in Claude Code: knowing more vs. trying harderClaude Code gives you two settings that both seem to "make the answer better": the model, and the effort level. But what do these actually do to the output? And how do you know whether to reach for a different model or just change the effort level?It's easy to assume that choosing a larger model like Fable gives you a smarter output than Sonnet, and that a higher effort level just means Claude thinks longer before it answers.The first assumption is true. Our largest models are more capable, according to industry-standard benchmarks.But effort means more than "thinking time." Effort controls how much work Claude does on your request overall. That includes how long it thinks, but also:• how many files it reads;• how much it verifies; and• how far it pushes through a multi-step task before checking in with you.At higher effort, Claude takes more of those actions (read files, run tests, double-check) before it comes back to you. At lower effort, it would rather ask you for more context than spend tokens figuring something out on its own.How model selection worksTo understand what the model setting actually controls, it helps to start at the very beginning, from the moment you press enter.Claude Code assembles your message together with the system prompt, tool definitions, your CLAUDE.md, the conversation history, and any files in context. All of this is sent as one request to the API.The model never sees any of that as plain text, though. The first thing that happens on the server is tokenization: the text gets split into pieces, and each piece is mapped to an integer from a fixed vocabulary the model was trained with. const might map to 1978, await might map to 4293. From here on, your prompt is an array of integers.The model's job is to take that array and predict which token comes next. It does this by computing a probability for every token in its vocabulary and picking from the top. After "const x = await", a well-trained model puts high probability on "fetch" (very likely) and near-zero on "banana" (not likely at all).What turns your input tokens into those probabilities is the weights (also called parameters): billions of numbers organized into large matrices. To predict one token, the model runs your input through those matrices (a long chain of matrix multiplications) and reads the probabilities at the end. The weights are where everything the model "knows" lives.The weights of each model are set during training, and by the time you're sending requests they're read-only. Nothing in your prompt, your CLAUDE.md, or your context changes them. If you've run into the word inference, that's all it means: using the model after training is done, with the weights fixed.Everything Claude knows about TypeScript, popular frameworks, or any other general programming knowledge was encoded into those weights at training time.Your prompt and context can still steer the prediction. Putting your real code in front of Claude is steering, and it works really well. However, this doesn't add anything to the weights themselves.If a library didn't exist when the model was trained, it isn't in the weights. You can put the docs in context and Claude will use them, but that's steering, not teaching. Claude's response is only influenced for that one request, but the underlying model hasn't retained anything.When Claude confidently calls an API that doesn't exist (a hallucination), that's the weights producing a token sequence that looks plausible from training patterns, not a failed lookup.So what does changing the model actually do? It swaps which set of frozen weights handles your request.The model doesn't generate a whole answer at once. It predicts one token, appends it to the sequence, and runs the whole computation again to get the next one. A 200-token response is 200 separate passes through the weights. This loop is where most of your wait time (and your output cost) comes from.The model setting decides which weights handle your request, and it also decides what each output token costs.What it doesn't decide is how many tokens get generated. That number can vary a lot for the same prompt, depending on how much work Claude decides to do.Which is exactly what effort controls.How effort worksWhile Claude Code is working on a task, the tokens it generates fall into a few categories:• Thinking: the reasoning you see streaming before and between actions.• Tool calls: structured blocks naming a tool like Read or Edit and its arguments, which Claude Code then parses and executes.• Text to you: the plan, progress updates, the summary at the end.These are all ordinary output tokens from the same loop, billed at the same rate. Thinking tokens, for example, are generated exactly like the other output tokens and stay in context for the rest of that turn.By the time Claude moves on to writing code, its earlier reasoning is part of the input, just like a file it read.So how does effort change any of this? The effort level is sent to the model as part of the request, right alongside your prompt. The model was trained to understand how to behave at each effort level, and that learned behavior is baked into the frozen weights.When your request arrives, effort is just one more input the model responds to, the same way it responds to your prompt text. It sets how thorough, and how certain, Claude needs to be before it considers the task done. That gets weighed on every turn, and higher confidence takes more tokens to reach.At higher effort levels, Claude often starts by creating a plan, and the effort level influences the depth and breadth of that plan. But the plan isn't frozen in place. As Claude gets results back from its actions, it updates its picture of how much progress it's made and how certain it is of the accumulated result.When step 1 of a three-hypothesis debugging plan finds the bug, "investigate hypotheses 2 and 3" may no longer be necessary. Claude will usually say this explicitly (e.g. "the first check found it, so the remaining checks aren't needed") and skip ahead. You see this happen in Claude Code when task lists get revised mid-run.Higher effort does make Claude more likely to double-check, like verifying the answer it found, or still look into the hypotheses it could have skipped. However, it generally won’t artificially inflate usage on a simple task just because the effort level is turned up. "Overthinking" is something our team specifically watches for during model training as it degrades effectiveness.Picking an effort levelFor most tasks, use the model's default effort level. The default is the level where Claude scales its token usage to what most people would want to spend on a task.Think of effort as a manual override on how hard and how long Claude works. Reach for it deliberately when you have a strong preference for thoroughness or speed based on your domain or the type of work you do, and treat it as a general preference, not a task-by-task decision.One practical note following the launch of Opus 4.8: in our testing, the default effort setting on Opus 4.8 produces better results for about the same amount of tokens as the default effort setting on Opus 4.7 on the same task.What to change when Claude gets it wrongWhen Claude gets something wrong, your first instinct shouldn't be to change a setting. It should be to look at the context you gave it. Is your prompt too vague? Is Claude connected to the right tools? Does it have the right skills?If you're increasing effort on a task that shouldn't need it, the fix is usually upstream: in your context, your CLAUDE.md, or how the task is scoped.But say you've given clear context and Claude still gets it wrong. The question to ask yourself is: did it not try hard enough, or did it not know enough?Model: the problem was too hardPick a larger model when the problem is genuinely hard, like subtle bugs, unfamiliar domains, architecture decisions. A larger model is what you want when the smaller model is confidently wrong no matter how much context you give it.Larger models are also better at handling ambiguity. On smaller models, specific instructions that direct the execution are a better recipe for success.Pick a smaller model when the work is routine: edits you can describe precisely, mechanical changes, questions about code that's already in context. There's no reason to pay for capability the task doesn't need.If Claude had all the pertinent context, clearly tried, and still got it wrong; that's a signal to pick a larger model. And if you're on the larger model and the work has been routine for a while, dropping down will increase speed and typically reduce cost without impacting the quality of the output.Effort: Claude didn't try hard enoughPick a higher effort level if Claude did it wrong by not trying hard enough: skipping a file, not running the tests, or not double-checking its work. This is most relevant if you'd selected an effort level below the model's default.The specialist, the expert, and the generalistOne way I like to think about the two settings is that Fable is a specialist who can handle problems almost no one else has, Opus is the expert, and Sonnet is a really good generalist. The effort level decides how much time any of them spends on your task.Opus at low effort is like getting five minutes with an expert who has deep experience with problems like yours. They bring knowledge that isn't anywhere in your codebase; patterns they've seen before, gotchas they know to check for, the kind of experience you only get from having solved a lot of similar problems. But five minutes means a quick read of your code, not a careful pass through every file.Sonnet at high effort is the generalist with the whole afternoon. They're great at coding, and they'll read everything, run things, double-check their work, and end up understanding your specific code thoroughly.Fable is the specialist you call when everyone else is stuck. Even at low effort, they'll spot the thing no one else would. That recognition is also what you're paying the most for, so it's worth saving it for the tasks that need it.None of these is universally "better". The model setting is roughly how capable; the effort setting is roughly how thorough. Most real tasks need some of both.Effort, model, and token consumptionSo how do model selection, effort, and token consumption all interact? It depends on the task.On routine work at the same effort level, both the larger and smaller models generally get it right. The larger model consumes more tokens with extra verification steps, at a higher per-token price. That's why dropping to the smaller model for routine stretches saves real money at no quality cost.On harder, multi-step work, the equation flips. The smaller model has to grind toward the limit of its ability, burning iterations, while the larger model reaches the same quality bar in fewer steps.You're paying more per token for the larger model, but on tasks that genuinely stretch the smaller one, the total cost per task can come out lower. And more importantly: the larger model can finish tasks the smaller one can't, even at the highest effort settings.This is most pronounced with Fable. On long, multi-step work it pulls furthest ahead. In our testing, it finished jobs Opus and Sonnet can't reach at any effort level. It also costs the most per token, which is the other reason to save it for the work that really needs it.The key point in the graphs above: effort picks how far Claude is willing to travel along the curve. That doesn't mean Claude will need to go that far to finish the task.Lastly, effort shapes token consumption, but it doesn't limit it. The only hard cap in the system is max_tokens, which truncates a response mid-stream when hit, but it's a blunt instrument and mostly relevant to API developers. Softer controls like task budgets or asking Claude to keep it brief in your prompt are more helpful. They're guidance the model is trained to follow (it'll look to wrap up as it gets near the limit) rather than a wall it runs into.Effort changes how much work Claude does. The model changes what Claude knows.When you're unhappy with a result, check the context before you touch either setting: give Claude a clear prompt, the right tools and skills, and a way to verify its own work.If Claude still gets it wrong, ask yourself: did it not know enough, or did it not try hard enough? Not knowing enough is a model problem, not trying hard enough is an effort problem.This article was written by @lydiahallie, member of technical staff on the Claude Code team.译Claude Code 的 model 和 effort 两种设置都旨在提升输出，但机制不同。model 越大，模型能力越强（基于行业标准基准测试）。effort 控制 Claude 在请求上的总工作量，包括思考时间、读取文件数、验证程度、多步任务推进深度等。高 effort 时 Claude 会执行更多操作（读文件、跑测试、再检查）；低 effort 时更倾向询问上下文。模型选择本质是切换不同的冻结权重集--权重在训练时固定，prompt 和上下文只能引导（steering）而不能改变权重。模型幻觉是权重产生看似合理但错误的 token 序列。

Anthropic 教程/实践编码

推荐理由：Claude Code 官方这篇把 model 和 effort 的取舍讲得比他处都透，读完就知道什么任务该堆算力、什么任务该降模型省钱。

7月8日

星期三 · 3 条

23:25

Replit ⠕@Replit精选

AI 评分 68/100

Replit 推出社区档案与力量排名New this week 🚀 Replit Community Profiles — Proof of Work for vibe coders.Your profile, your flex. Get an activity graph of your agent usage and checkpoints, plus a Replit Power Ranking for pro users.Log in, claim your profile, pick your best projects, and share your stats with friends.See it in action now → http://replit.com/community译本周新功能 🚀 Replit 社区档案--vibe coders 的工作证明。你的档案，你的展示。获取你的智能体使用和检查点的活跃度图表，外加面向专业用户的 Replit 力量排名。登录，认领你的档案，挑选你最棒的项目，与朋友分享你的数据。立即查看 → http://replit.com/community

智能体产品更新编码

推荐理由：Replit 给 vibe coders 加上了个人主页和工作证明，用活动图和排名展示 agent 使用，让 AI 编程社区有了社交层，但实质还是功能小更新，对非重度用户意义有限。

12:44

Hacker News 热门（buzzing.cc 中文翻译）精选

AI 评分 71/100

AI 审计代理在 Cloudflare CIRCL 中发现 7 个漏洞

zkSecurity 的 AI 审计代理 zkao 持续扫描 Cloudflare 的 CIRCL 密码学库，使用 Opus 4.6 + skills 和 GPT-5.3 + skills 等模型发现并确认了 7 个真实漏洞。其中包括阈值 RSA 中 float64 精度丢失（AI 自评 Critical）和属性基加密（CP-ABE）访问控制完全失效（Critical，由 zkao 自行发现）。所有漏洞已在上游修复，多数在 HackerOne 上获得确认和奖励。AI 生成的候选发现仍需人工验证，但 zkao 已能自动完成大部分验证工作。

Anthropic OpenAI 安全/对齐编码

推荐理由：zkSecurity用AI扫了Cloudflare的密码学库，挖出7个真实漏洞，从浮点数精度损失到访问控制完全破防。这是AI在密码学审计里第一次证明自己能找到能用的漏洞，不是纸上谈兵。虽然后面发现AI对严重性的判断还很瞎，但整体值得安全从业者一读。

02:12

Hacker News 热门（buzzing.cc 中文翻译）精选

AI 评分 73/100

YC CEO声称每日用AI部署3.7万行代码，开发者审查发现前端代码大量臃肿低效

Y Combinator CEO Garry Tan在X上宣称，他与AI编码代理每天在五个项目中部署37000行代码，并保持连续72天发布记录。波兰开发者Gregorein深入审查Tan网站前端代码，发现大量臃肿与低效问题：页面加载169次请求、总计6.42MB数据（对比Hacker News仅7次12KB）；包含28个测试文件、78个未使用的JavaScript控制器、八种格式Logo（含空文件）、未压缩的旧PNG等。Gregorein指出，AI虽能快速生成代码，但质量仍应优先于数量。

智能体现象/趋势编码

推荐理由：Garry Tan 日行三万七千行的神话被代码审查拆穿，这不是节奏问题，是 AI 编码‘有量无质’的典型病征。认为 AI 编码能光速开发的人该冷静一下了。

7月7日

星期二 · 2 条

03:13

ClaudeDevs@ClaudeDevs精选

AI 评分 70/100

Claude Code 团队详解四种智能体循环类型http://x.com/i/article/2074204645845839872Getting started with loopsThere’s a lot of talk right now about "designing loops" instead of prompting your coding agent. If you spend some time on X trying to pin down what a loop actually is, you'll come across multiple different answers.On the Claude Code team, we define loops as agents repeating cycles of work until a stop condition is met. We categorize a few different types of loops based on:• How they are triggered• How they are stopped• What Claude Code primitive is used• What type of task is most appropriate for each.We’ll cover the main loop types, when to use each, and how to maintain code quality while managing token usage. Not all tasks require complex loops; start with the simplest solution and use these patterns selectively.Turn-based loops• Triggered by: A user prompt.• Stop criteria: Claude judges it has completed the task or needs additional context.• Best used for: Shorter tasks that are not part of a regular process or schedule.• Managed usage by: Write specific prompts and improve verification using skills to reduce the number of turns.Every prompt you send starts a manual loop with you directing each turn. Claude gathers context, takes action, checks its work, repeats if needed, and responds. We call this the agentic loop.For example, ask Claude to create a like button. It reads your code, makes the edit, runs the tests, and hands back something it believes works. You then manually check the work, and write the next prompt.You can improve the verification step by encoding your manual steps as a SKILL.md so Claude can check more of its own work, end-to-end. This should include tools or connectors to allow Claude to see, measure or interact with the result. The more quantitative the checks are, the easier it is for Claude to self-verify.For example, in your SKILL.md file you may specify:Goal-based loop (/goal)• Triggered by: A manual prompt in real-time.• Stop criteria: Goal achieved OR maximum number of turns reached.• Best used for: Tasks that have verifiable exit criteria.• Managed usage by: Setting a specific completion criteria and explicit turn caps, “stop after 5 tries.”Sometimes, a single turn is not enough, especially for more complex tasks. Agents do better when they can iterate. You can extend how long Claude keeps iterating by defining what done looks like with /goal.When you define the success criteria, Claude doesn’t have to make a determination on what is “good enough” and end the loop early. Each time Claude tries to stop, an evaluator model checks your condition and sends it back to work until the goal is met or a number of turns you define is reached.This is why deterministic criteria, such as number of tests passed or clearing a certain score threshold, are so effective.For example:Time-based loop (/loop and /schedule)• Triggered by: A specified time interval.• Stop criteria: You cancel it, or the work completes (the PR merges, the queue is empty).• Best used for: For recurring work, or interfacing with external environments / systems.• Managed usage by: Set longer intervals or react based on events rather than time.Some agentic work is recurring: the task stays the same and only the inputs change. For example, summarizing Slack messages every morning. Other work depends on external systems, and a simple way to interface with one is to check it on an interval and react to what changed. For example, a PR which may receive code reviews or fail CI.For these, you can trigger when Claude runs with /loop which re-runs a prompt on an interval. For example:/loop runs on your computer, so if you turn it off, it stops. You can move the loop to the cloud by creating a routine with /schedule.Proactive loops• Triggered by: An event or schedule, with no human in real time.• Stop criteria: Each task exits when its goal is met. The routine itself runs until you turn it off.• Best used for: Recurring streams of well-defined work: bug reports, issue triage, migrations, dependency upgrades, etc.• Managed usage by: Routing routines to smaller, faster models and using the most capable model for judgment calls.The primitives above, along with other Claude Code features like auto mode and dynamic workflows (research preview) can be composed into a loop for long-running work.For example, to handle incoming feedback, you can use:1. /schedule (research preview) to run a routine that checks for new reports1. /goal to define what done looks and skills to document how to verify it1. Dynamic workflows to orchestrate agents that triage each report, fix it, and review the fix1. Auto mode so the routine runs without stopping to ask for permissionPutting it together, a prompt could look like this:Maintaining code qualityThe quality of a loop’s output depends on the system around it. When designing the system:• Keep the codebase itself clean: Claude follows patterns and conventions that already exist in your codebase.• Give Claude a way to verify its own work: Encode what good looks like for you and your team with skills.• Make docs easy to reach: Frameworks and libraries docs have up-to-date best practices.• Use a second agent for code reviews: A reviewer with fresh context is less biased and not influenced by the main agent’s reasoning. You can use the built-in /code-review skill or Code Review for Github.When an individual result doesn’t meet the standard, don’t stop at fixing the individual issue, try to encode it to improve the system for all future iterations.Managing token usageTo manage token usage, loops should have clear boundaries:• Choose the right primitive and model for the job: Smaller tasks don’t need multiple agents or loops. Some tasks can use cheaper and faster models.• Define clear success and stop criteria: Be specific about what done looks like so Claude can arrive at the solution sooner (but not too soon).• Pilot before a large run: Dynamic workflows can spawn hundreds of agents. Gauge usage on a smaller slice of the work first.• Use scripts for deterministic work: Running a script is cheaper than reasoning through the steps. For example, a PDF skill can ship a form-filling script that Claude runs each time, instead of re-deriving the code.• Don’t run routines more often that you need to: Match the interval to how often the thing you’re watching changes• Review usage: The /usage command breaks down recent usage by skills, subagents, and MCPs, /goal with no arguments shows number of turns and token usage so far, /workflows shows each agent’s token usage and you can stop an agent at any time.Getting startedTo summarize:To get started with loops, look at the work you already do. Pick one task where you’re the bottleneck and ask which piece you could hand off: can you write the verification check? Is the goal clear enough? Does the work arrive on a schedule?Once you have an idea, run the loop, observe the results like where it stalls or over-reaches, and don’t be afraid to iterate on it.For more information, read the Claude Code docs on running agents in parallel, as well as the loop, schedule, goal, and dynamic workflows pages.This article was written by @delba_oliveira译Claude Code 团队将"设计循环"定义为智能体重复工作直到满足停止条件，划分四种类型：1）回合循环--手动提示触发，Claude 自判完成，适合短任务，可通过 SKILL.md 提升验证；2）目标循环--/goal 手动触发，达成目标或达最大轮数停止，需确定性完成标准（如测试通过数）；3）时间循环--/loop 和 /schedule 按间隔触发，适合同步消息、检查 PR 等重复任务，可云端运行；4）主动循环--事件或计划触发，无人实时参与，每个子任务独立退出。建议从最简单方案开始，选择性使用复杂循环。

智能体 Anthropic 教程/实践编码

推荐理由：Claude Code 团队官方的循环设计指南，把 `/goal`、`/loop` 这些原语讲得很清楚，想从单次提示转向自主代理工作流的开发者可以直接照着搭。

02:20

Claude：Blog（网页）精选

AI 评分 70/100

Claude Fable实地指南：发现你的未知

Claude Fable是第一款要求用户主动澄清未知才能获得高质量工作的模型。与Claude Fable协作是一个在实现前后迭代发现未知的过程。通过将问题分解为已知的已知、已知的未知、未知的已知和未知的未知四类，用户可以借助Claude Fable和Claude Code进行盲点检查、头脑风暴、原型设计、实现笔记记录以及答辩解释，从而高效挖掘并解决深藏于代码库和设计与实现中的潜在问题。

智能体 Anthropic 教程/实践编码

推荐理由：Anthropic 官方分享的 Claude Fable 协作方法论，把「发现未知」拆成盲点扫描、原型、面试等可操作步骤，如果你用 Claude Code 但常觉得代理跑偏，这篇是必读实践指南。

7月6日

星期一 · 1 条

20:07

Hacker News 热门（buzzing.cc 中文翻译）精选

AI 评分 77/100

AI颠覆初级程序员就业市场：斯坦福数据揭示年轻开发者就业锐减19%

斯坦福数字经济实验室基于ADP薪资数据发现，美国22-25岁软件开发人员就业较2022年峰值下降19%，而41-49岁增长14%。入门级岗位招聘减少28%，计算机科学毕业生失业率达6.1%，高于文科专业。核心推手是2024-2025年兴起的智能体编程（Agentic programming）。总程序员就业增长4.4%，但全部来自年长群体。GitHub一年新增3600万账号，80%新用户一周内使用Copilot。编程工作未消失，但“初级程序员”头衔正在消亡。

GitHub 现象/趋势编码

推荐理由：用斯坦福、BLS、GitHub和App Store的数据把“初级程序员被替代”讲成了确凿事实，更关键是指出编程正从职业变成每个人的基本能力——对所有写代码的人是必读。

7月5日

星期日 · 1 条

22:21

Meituan LongCat@Meituan_LongCat精选

AI 评分 81/100

美团 LongCat-2.0 完全开源（MIT 许可），1.6T MoE 模型开放权重与推理代码🐱 LongCat-2.0 is now fully open-source — MIT licensed, no restrictions.Since our launch a few days ago, the response from the community has been incredible. Thank you for all the feedback, discussions, and interest.Today, we’re releasing the model weights and inference code to everyone. ◆ 1.6T MoE · ~48B active · 1M token context ◆ Agent-native: Integrates directly with Claude Code, OpenClaw, and Hermes Agent ◆ Deployment: Support both GPU and NPU platforms— verified on large-scale domestic clusters📑 Tech Blog: https://longcat.ai/blog/longcat-2.0/ 🤗 HuggingFace: https://huggingface.co/meituan-longcat/LongCat-2.0 💻 GitHub: https://github.com/meituan-longcat/LongCat-2.0 🪄 ModelScope: https://modelscope.ai/collections/meituan-longcat/LongCat-20 👇 Inference Code GPU: https://github.com/sgl-project/sglang/pull/30042 NPU: https://github.com/meituan-longcat/SGLang-FluentLLM/tree/npu译美团今日宣布 LongCat-2.0 完全开源（MIT 许可），公开模型权重与推理代码。该模型为 MoE 架构，总参数量 1.6T，每 token 激活约 48B，支持 1M token 上下文。技术亮点包括 LongCat Sparse Attention 高效处理长文本、Zero-Compute Experts 动态激活 33B-56B 零浪费计算、MOPD 按任务路由 Agent/Reasoning/Interaction 三组专家。Benchmark 成绩：Terminal-Bench 2.1 70.8；SWE-bench Pro 59.5（超越 GPT-5.5 的 58.6）；SWE-bench Multilingual 77.3；FORTE 73.2；RWSearch 78.8；BrowseComp 79.9。原生集成 Claude Code、OpenClaw、Hermes Agent 等工具，支持 GPU 与 NPU 部署，已在大规模国内集群验证。

Meituan LongCat: 推出 LongCat-2.0 🐱 1.6T 参数 · MoE 架构，约 48B 活跃参数 · 1M 上下文窗口这是 @OpenRouter 上 Owl Alpha 背后的完整模型--现已可用。从零开始为智能体编程构建： ◆ LongC...

智能体开源生态模型发布编码

另有 1 家信源报道

推荐理由：国内大厂首个在 SWE-bench Pro 上超过 GPT-5.5 的开源模型，MIT 协议无任何限制，搞 agentic coding 的团队可以直接用，是个重要转折。

7月4日

星期六 · 3 条

03:44

Hacker News 热门（buzzing.cc 中文翻译）精选

AI 评分 83/100

pxpipe：通过图像化压缩输入token降低Claude Code成本

pxpipe是一个本地代理，将系统提示、工具文档和历史记录等密集文本渲染为PNG图像，利用图像token成本取决于像素尺寸的特性压缩输入token。在Fable 5模型上，约25k文本token压缩为约2.7k图像token，端到端账单降低59–70%。SWE-bench Lite 10个实例全部通过，成本从$54降至$27；SWE-bench Pro 19对测试中18对判定一致，单次请求成本降低约60%。该方法有损（精确ID等需保持文本），默认仅处理claude-fable-5请求，可通过PXPIPE_MODELS变量控制。

GitHub 开源/仓库编码

推荐理由：pxpipe 通过把大量上下文渲染成图像来降低 token 开销，实测能削减 60-70% 的账单，对重度使用 Claude Code 的开发者很诱人，但它有损，精确值可能读错，适合容错高的编码场景。

03:22

Simon Willison 博客精选

AI 评分 73/100

Fable 的判断力：Simon Willison 从 Claude Code 团队获得的效率技巧

Simon Willison 在 AIE 上与 Claude Code 团队交流后建议，让 Fable（以及 Opus）用自己的判断力工作，而非硬性规定行为。例如，直接让 Fable 自行决定何时编写测试，比给出具体规则更好。为应对价格即将上涨、节省 Fable token，Jesse Vincent 的另一个技巧是告诉 Fable 将较小任务委托给较低功耗模型（Sonnet 用于实质性实现、Haiku 用于机械修改），主循环保留判断、审计和数据合成等任务。Willison 已将提示词存入 Claude Code 记忆文件，实际效果良好，Fable token 消耗速度明显下降。

智能体 Anthropic 教程/实践编码

推荐理由：Simon 从 Claude Code 团队得到的实战技巧：别硬性规定 Fable 怎么写测试、用哪个模型，让它自己判断。他实测这条 prompt 能明显节省代币消耗，Fable 涨价前偷时间的利器。

02:11

Thariq@trq212精选

AI 评分 69/100

Fable使用指南：发现你的未知http://x.com/i/article/2073090223194755072A Field Guide to Fable: Finding Your UnknownsWorking with Claude Fable 5 keeps re-teaching me an old lesson: the map is not the territory.The map, a representation of the work to be done, is my prompts and skills and context, it’s what I give Claude. The territory is where the work needs to happen, the codebase, the real world, its actual constraints.The difference between the map and the territory is what I call unknowns. When Claude runs into an unknown, it needs to make a decision based on its best guess of what I want. The more work being done, the more unknowns Claude might run intoFable is the first model where I find the quality of the work is bottlenecked by my ability to clarify its unknowns.Importantly, just planning ahead isn’t always enough. You can find unknowns deep in implementation, or your unknowns may point you to the fact that you should actually be solving the problem in a different way altogether.I’ve found that working with Fable is an iterative process of discovering my unknowns before, during, and after implementation.I've made some example artifacts for finding unknowns here, but be sure to come back to build the intuition for when to use them.Knowing your unknownsWhat are your unknowns? When I come to Claude with a problem I tend to break it down in 4 ways:• Known Knowns: This is essentially what is in my prompt. What do I tell the agent that I want?• Known Unknowns: What haven't I figured out yet, but I’m aware that I haven’t?• Unknown Knowns: What's so obvious I’d never write it down, but would recognize it if I saw it?• Unknown Unknowns: What haven't I considered at all? What knowledge am I not aware of? Do I know how good something can be?The best agentic coders are good have relatively few unknowns. Watching someone like Boris or Jarred prompt, it is obvious to me that they know what they want in-detail. They are deeply in-sync with both the codebase and the model behaviors.But they also assume unknowns. In many ways, reducing and planning for your unknowns is the skill of agentic coding. But luckily, this is a skill you can improve at, by working with Claude.Help Claude help youInstructing Claude is a delicate balance. If you are too specific, Claude will follow your instructions even when a pivot may be more appropriate. If you are too vague, Claude will often make choices and assumptions based on industry best practices that may not be a fit for your task.When you don’t account for your unknowns you fail both ways. You don't know when the path will be filled with obstacles and you don’t know when the path will be clear, but you still want Claude to veer.Claude can help you discover your unknowns faster. It can search through your codebase and the internet extremely quickly and it knows much more about the average topic than you. It can also iterate from failure faster.The most important part of this process is to give Claude context about your starting point. For example, tell it where you are in your thought process; disclose your experience with the problem and codebase; and let it work with you like a thought partner.I've previously written about using HTML with Claude, in almost all of these cases, a HTML artifact is the best way to visualize and represent it.In this article I detail some of the patterns I use to uncover these unknowns. I don't use every technique each time, but it's a useful collection of techniques to have.Pre-implementationBlind Spot PassWhen starting work, one of the most useful things you can do is understand your blindspots. For example, if you’re writing a feature in a new part of the codebase or using Claude to help you with unfamiliar work like iterating on a design, you’re likely to have a lot of unknown unknowns.You may not know what questions to ask, what good looks like, what historical work has been done or what potholes to avoid.To do this, you can ask Claude to help you find your unknown unknowns and explain them to you. I like to use the literal words “blindspot pass” and “unknown unknowns”. Giving it context on who you are and what you know is usually important forExample Prompts:• “I'm working on adding a new auth provider but I know nothing about the auth modules in this codebase. Can you do a blindspot pass to help me figure out my relevant unknown unknowns and help me prompt you better.”• “I don’t know what color grading is but I need to grade this video. Can you teach me to understand my unknown unknowns about color grading, so that I can prompt better?”Brainstorms and prototypesWhen I’m working in an area with a lot of unknown knowns, involving criteria I only know to define when I see it, I like to ask Claude to brainstorm and prototype with me.It’s extremely valuable to identify and verbalize unknown knowns early during prototyping, because finding them out during implementation can be (relatively) expensive. Small changes in a feature or spec can cause drastically different implementations in code and it can be more difficult for your agent to revert previous changes.For example, you may just want to see how a button added to a frame looks without having to wire up a backend route or maintaining additional state in the frontend.Visual design is something that for me is difficult to articulate, but I know what I want when I see it. In these cases, I’ll ask for several design approaches to an artifact.I also start almost every coding session with an exploration or brainstorming phase. This helps me start with intent to define the project’s scope. Claude often finds high-value approaches I would have missed and sometimes misses the forest through the trees. Brainstorming prevents me from setting too narrow or too wide a scope.Example prompts:• "I want a dashboard for this data but I have no visual taste and don't know what's possible. Make me an HTML page with 4 wildly different design directions so I can react to them.”• “Before wiring anything up, make a single HTML file mocking the new editor toolbar with fake data. I want to react to the layout before you touch the treal app."• "Here's my rough problem: users churn after onboarding. Search the codebase and brainstorm 10 places we could intervene, from cheapest to most ambitious. I'll tell you which ones resonate."InterviewsOnce I’ve done sufficient brainstorming, I likely still have unknowns.In this case, I ask Claude to interview me about any unknowns or ambiguities. When asking Claude to interview you, try and give it context about your problem to guide its questions. Here are some examples.Example prompts:• "Interview me one question at a time about anything ambiguous, prioritize questions where my answer would change the architecture."ReferencesSometimes you can’t describe what you want in detail. For example, you might not have the language or it might be so complicated that it would take you quite a while.In this case, the best answer is a reference. While you can include diagrams, documentation or pictures, the absolute best reference is source code.If you have a library that implements something in a certain way or a design component you really like, just point Fable at the folder and tell it what to look for, even if it’s in a different language.This is also the way Claude Design works. You don't have to hand it a file (although you can do that too). You can point it at a module on a website you like, and it reads the underlying code, not just the screenshot. This provides much richer detail around the markup, structure, and how the component is actually built.Example prompts:• This Rust crate in vendor/rate-limiter implements the exact backoff behavior I want. Read it and reimplement the same semantics in our TypeScript API client.Implementation PlansWhen I think I’m ready to implement, I tend to ask Claude to put together an implementation plan for me to review that focuses on the parts that might be most likely to change, for example to review data models, type interfaces or UX flows. This allows Claude to surface things I might actually need to alter.Example Prompts:• Write an implementation plan in HTML, but lead with the decisions I'm most likely to tweak with: data model changes, new type interfaces, and anything user-facing. Bury the mechanical refactoring at the bottom, I trust you on that part."During implementationImplementation notesOnce I am satisfied with my plan, I make a new session and pass any artifacts to the prompt. For example, I might pass in a spec file and a prototype and ask an agent to implement it.But the truth is that no matter how much planning you do, there are always unknown unknowns lurking. The agent may find during its work that it needs to take a different tack due to an edge case it found in the code.I ask Claude Code to keep a temporary ‘implementation-notes.md’ (or .html) file where it keeps track of decisions it makes so we can learn from our next attempt.Example prompts:• "Keep an implementation-notes.md file. If you hit an edge case that forces you to deviate from the plan, pick the conservative option, log it under 'Deviations', and keep going."Post implementationPitches and explainersOne of the most important parts of shipping something is getting buy-in and approvals. Building pitch and explainer artifacts in the final document helps:• Accelerate understanding when reviewers start with the same unknowns you did• Accelerate approvals when experts want to see you accounted for the unknowns and common failure points they would have anticipatedExample prompts:• "Package the prototype, the spec, and the implementation notes into a single doc I can drop in Slack to get buy-in. Lead with the demo GIF."QuizzesAfter a long working session, Claude might have accomplished a lot more than I realized. Reading the code diffs can only give me a light understanding of what happened, since much of the behavior will depend on existing code paths.Asking Claude to quiz me about the change after giving me a bunch of context helps me understand what happens. I only merge after I pass the quiz perfectly.Example prompts:• “I want to make sure I understand everything that's happened in this change. Give me a HTML report on the changes for me to read and understand with context, intuition, what was done, etc. and a quiz at the bottom on the changes that I must pass.”How this comes together: launching FableThe launch video for Fable was edited entirely by Claude Code. This was a new domain for me and I’m by no means an expert.So I started with what I did know. I knew that Claude could use code to edit videos and transcribe them, but I wasn’t sure if it was accurate enough. I then asked Claude to explain to me how transcription like Whisper worked, and whether I would be able to accurately cut out things like ums or large pauses using ffmpeg.I wanted Claude to create a UI that was timed with the words I was saying, but wasn’t sure if it would be able to so I asked Claude to create a prototype video using Remotion and a transcription to see if it would work.Finally, the video itself looked a bit muted, which I knew was the result of color grading but I didn’t really know what color grading was. My first pass attempt was to try and get Claude to do a few variations to pick, but I realized that I didn’t know what “good” looked like when it came to color grading. So instead, I asked Claude to teach me about color grading to discover my unknowns.You can watch a more in-depth explanation on that here.Matching the Map and TerritoryThe better models get, the more you can achieve with the right approach. When a long-horizon task comes back wrong, it's likely you need to spend more time defining your unknowns or creating an implementation plan that allows for Claude to improvise through them.Every explainer, brainstorm, interview, prototype, and reference is a cheap way to find out what you didn't know before it gets expensive to fix.So start your next project by asking Claude to help you find your unknowns.译作者分享与Claude Fable的协作经验，指出"地图≠领土"：提示词与上下文（地图）与实际代码库和约束（领土）之间存在未知。他将未知分为四象限：已知-已知、已知-未知、未知-已知、未知-未知。顶级智能体程序员善于减少未知并预设预案。Fable是首个模型，其工作质量受限于用户澄清未知的能力。Claude可通过快速搜索代码库和互联网、从失败中迭代，帮用户定位未知。具体技巧包括实施前的"盲点检查"及迭代优化；避免指令过于具体或模糊，应让Claude协助发现未知。

智能体 Anthropic 教程/实践编码

推荐理由：Thariq 总结了一套与 Claude Fable 5 协作时发现「未知的未知」的方法论，从盲点扫描到事后测验，对想用好代理编码的开发者有实操价值。

7月3日

星期五 · 3 条

18:14

Hacker News 热门（buzzing.cc 中文翻译）精选

AI 评分 72/100

面向 Web 开发者的 Safari MCP 服务器

Safari Technology Preview 247 推出 Safari MCP 服务器，基于 Model Context Protocol，允许任何 MCP 兼容客户端连接 Safari 浏览器窗口。智能体可获取 DOM、网络请求、截图、控制台输出等信息，自主完成调试、性能分析、可访问性检查等任务。内置 browser_console_messages、screenshot、evaluate_javascript、list_network_requests 等工具。开发者安装后启用“远程自动化与外部智能体”选项，即可通过命令接入，减少窗口切换。

MCP/工具产品更新编码

推荐理由：Safari 首次以官方身份推出 MCP 服务器，让 AI 编程助手能直接调试浏览器渲染，对前端开发者做兼容性测试和性能检查很实用，不过局限在 Safari 生态。

14:44

Hacker News 热门（buzzing.cc 中文翻译）精选

AI 评分 70/100

《Fable》通关指南：短绳AI编程法

专业开发者经过一年多研究，总结出使用AI编码代理的“短绳方法”。该方法要求开发者全程参与：先规划并分解任务，从不使用YOLO模式，每次变更前审查差异并拒绝不想要的更改，每个子任务后提交以防止AI误操作（如Opus曾出现破坏性行为）。最终需进行人工与AI双重PR审查，PR须注明使用模型，提交者须亲自审查自己PR的代码。即便不用前沿模型，此法也能产出超越Fable 5的代码质量。

智能体教程/实践编码

推荐理由：这篇是资深安全开发者一年的实战总结，提出的「短绳法」把AI代理栓紧，不是让开发者当甩手掌柜，而是逼你逐行审查，对代码质量死磕到底，比那些鼓吹全自动的大路货更有实操价值。

01:39

LangChain：Blog（RSS）精选

AI 评分 64/100

OpenWiki：为编码智能体生成并维护开源仓库文档

LangChain 推出 OpenWiki，一个为编码智能体自动生成和维护代码库文档的开源工具。它让智能体能直接检索所需的仓库上下文，无需将所有内容加载到单个指令文件中。

产品更新开源生态编码

推荐理由：LangChain 开源的这个文档生成代理解决了编码代理上下文管理的一个痛点，对重度使用 agent 做开发的团队很实用。

7月2日

星期四 · 2 条

19:14

Hacker News 热门（buzzing.cc 中文翻译）精选

AI 评分 71/100

Senior SWE-Bench：评估AI智能体作为高级工程师的基准测试

Senior SWE-Bench是一个开源基准测试，用于评估AI智能体完成高级软件工程师级别任务的能力。任务分功能开发与Bug修复两类：功能任务指令类似自然语言消息，采用验证智能体基于专家配方自动生成行为测试；Bug任务要求根据日志、profiling等运行时信息深入调查。排行榜显示，Claude Opus 4.8搭配Mini-SWE-Agent（max effort）通过率24.0%，Claude Sonnet 5为19.4%，GPT-5.5为16.0%，最强前沿模型在超75%任务中未能达到高级工程师级别的正确性与品味。每个功能任务平均涉及11个文件，最强智能体也需数百步完成；中位指令长度仅为SWE-Bench Pro的31%。任务来源于从库到多服务应用的仓库PR，由拥有数百次提交的工程师编写。

开源/仓库编码评测/基准

推荐理由：这个新基准把 AI 编程代理的评估拉到了更真实的复杂度，顶尖模型也只有不到四分之一的成功率，做 coding agent 的都该拿它测一测，它会比 SWE-bench 更挑出工程师的“手感”。

16:40

Hacker News 热门（buzzing.cc 中文翻译）精选

AI 评分 71/100

Kimi K2.7 Code 已在 GitHub Copilot 上正式发布

Kimi K2.7 Code 开源权重模型已在 GitHub Copilot 中正式可用，成为 Copilot 模型选择器首个可选的开源权重模型，为编程工作流提供更低成本选择。该模型由 GitHub 托管于 Microsoft Azure，按供应商列表价格以用量计费。逐步向 Copilot Pro、Pro+ 和 Max 计划用户推送，用户可在 Visual Studio Code 1.127.0 或更新版本、Visual Studio 17.14.6 或更新版本、JetBrains 1.9.1-251 或更新版本、Xcode、Eclipse 等 IDE 及 Copilot CLI、GitHub.com、GitHub Mobile 等平台中选用。后续几周将扩展至 Copilot Business 和 Enterprise，当前默认关闭，需管理员在 Copilot 设置中启用策略。

GitHub 产品更新开源生态编码

另有 1 家信源报道

推荐理由：GitHub Copilot 首次把开源权重模型放进模型选择器，Kimi K2.7 Code 作为低价选项可能会改变很多开发者的使用习惯，对个人开发者尤其友好。

精选归档 · 第 6 页

7月9日

7月8日

7月7日

7月6日

7月5日

7月4日

7月3日

7月2日

相关主题