按内容分类归入的教程，对应分类 tip。
Just as title says, in the world of ai accelerated code production, when you're in charge of a repo or project, how do you usually look at code from proposed changes ? I'm interested to find what your workflows look like these days. Comments URL: https://news.ycombinator.com/item?id=50076985 Points: 1 # Comments: 0
在数十或数百个 AWS 账户之间管理 AI 模型访问权限时，如果每个账户都必须单独接受 AWS Marketplace Private Pricing Offers，就会带来摩擦。本文介绍了在 AWS License Manager 中激活 MPPO 授权的两种方式：一种是用于一次性修复的轻量级脚本，另一种是用于持续事件驱动处理的 CDK 自动化方案。
Hey HN! I have been dabbling into some hobby projects that require designing custom 3D printed models. I have been relying on AI models, mostly GPT Sol and Astra through Codex, and giving them certain tools such as Blender MCP and OpenSCAD CLI to design. My end goal is 3D printable designs ( .stl etc). The results have been good but not great. Iterating and improving them is such a pain in the ass. I want to know which specific tools or workflows you would recommend I should try. Thanks in advance! Comments URL: https://news.ycombinator.com/item?id=50072103 Points: 1 # Comments: 0
If the agent isn't using my diagnostics library, I could introspect and update AGENTS.md, but there's still a delta, and it'll drift. Instead, I write a pre-commit hook that checks the git diff for direct calls to observability modules that bypass my diagnostics module. Boom: fail the commit, inject a prompt telling the agent to use the diagnostics library. All of a sudden it's ten out of ten. — Geoffrey Huntley , nobody should type code by hand anymore. here's what's left. Tags: coding-agents , generative-ai , git , agentic-engineering , ai , geoffrey-huntley , llms
Learn how to run OpenAI GPT-6 Sol, Luna, and Astra on Amazon Bedrock through global cross-Region inference from Singapore, Jakarta, Thailand, Malaysia, and Taipei. This post covers the Converse and OpenAI-compatible APIs, IAM and SCP permissions, quota sizing, and monitoring inference from your source Region.
Comments URL: https://news.ycombinator.com/item?id=50058946 Points: 1 # Comments: 0
了解如何在 Amazon EKS 上使用多节点 Ray LLM Deep Learning Containers，将一个大型语言模型部署到两个 GPU 节点上，并在一个兼容 OpenAI 的端点后配置独立的预填充节点和解码节点。预构建容器附带完整的推理技术栈，因此您只需配置部署，无需自行组装。
Comments URL: https://news.ycombinator.com/item?id=50055864 Points: 2 # Comments: 2
Most traditional enterprise systems were built around three assumptions: Jobs finish quickly, retrying one is free and the same input always produces the same output. Agentic workloads break all three of these expectations, which is why pilots that perform well turn into operational problems once they run unattended. The difficulty is rarely the model; it’s […] The post Agentic workloads break assumptions about software testing. Here’s how to cope appeared first on SiliconANGLE .
What resources (authors, podcasts, books, etc) do you follow to keep up with best practices, patterns, methodologies, for software development with AI? There is so much noise that I want to know a few trusted resources (especially authors) to follow to keep up with latest best practices (an example of an author in what I have in mind would be Simon Willison). Comments URL: https://news.ycombinator.com/item?id=50038971 Points: 3 # Comments: 0
让 AI 发挥作用：数百次成功部署的经验教训
面向初创公司的实用指南，涵盖迁移至 Responses API、设计智能体、优化提示词、引导 GPT-5 模型，以及构建可靠的 AI 工作流。
一份关于设计、编排和部署 AI 代理的综合指南，涵盖应用场景、模型选择、工具设计、防护机制以及多代理模式。
实用指南，展示小型团队如何使用 ChatGPT 分析数据、制作营销材料、管理预算、主持会议并做出更明智的决策。
Fellow founders, I know AI writing is strictly forbidden here. But I was wondering if yall hand write every single post on X or on Linkedin for ship updates or user engagement posts. For small team like mine, I'm in charge of my own account. Not gonna lie, content batching and writing everything from scratch are extra work for me. On the other side, when I outsource my content generation to AI, my personality gets washed away. I'm curious how other founders approach this. Do you use AI to some extent for content batching, drafting or editing? How do you draw the line? Comments URL: https://news.ycombinator.com/item?id=50002798 Points: 1 # Comments: 0
The biggest barrier to AI adoption isn't awareness. It's the gap between talking about AI and building with it. Here's the playbook we used to turn non-technical, customer-facing professionals into confident AI builders in six weeks, and how your organization can replicate it.
AWS DevOps Agent 能够诊断生产环境中的事件，但被限制在观察与报告模式下，因此不会直接修改资源。本文展示如何使用 AWS Lambda Durable Functions、Amazon EventBridge 和 Amazon Bedrock，将其调查摘要转化为经过预先验证的修复方案，值班工程师只需一次操作即可批准。
The RPA-era ROI model misses most of the value agentic automation creates. This post gives AI center of excellence leaders a framework to size the full value of agents across time savings, exception handling, decision quality, and maintenance economics, and to prioritize which workflows to automate first.
For those who have let AI build sufficiently large projects, what worked out better for you: AI writing raw CSS, or restricting it to Tailwind utility classes? Comments URL: https://news.ycombinator.com/item?id=49988056 Points: 1 # Comments: 0
Explore a comprehensive coding guide to Laya, the open-source zero-shot decision engine. Learn how to implement typed decisions, fit custom temperatures, and build reliable abstention gates using real-world CLINC150 banking data. The post A Developer’s Guide to Laya: Zero-Shot Decisions and Calibration appeared first on MarkTechPost .
现成的 AI 助手会在对话之间遗忘你。本文介绍如何在 Amazon Bedrock AgentCore 运行时上使用 OpenClaw 构建一个能够积累上下文的个人助手，并借助 AgentCore memory 将一次性的聊天记录转化为持久化、结构化的知识，再通过元数据筛选器进行检索。
Discover how to construct an end-to-end streaming robotics learning pipeline using the NVIDIA Cosmos3-DROID dataset without local downloads, leveraging byte-range Parquet reads, behavior cloning, and temporal ensembling. The post Building a Streaming Robotics Learning Pipeline Using NVIDIA Cosmos3-DROID appeared first on MarkTechPost .
多智能体系统需要比流畅的响应更深入的保障：它们必须选择正确的工具、遵守约束条件，并解释其决策。了解如何构建基于 Strands 的多智能体供应链决策系统，并使用 Amazon Bedrock AgentCore Evaluations 通过内置评估器、自定义评估器和可解释性评估器对其进行评估。
使用 LangChain 在 Amazon Bedrock Managed Knowledge Base 上构建检索增强生成（RAG）应用，了解智能体式检索如何处理单次检索难以妥善回答的多部分问题。通过两种路径运行相同的查询，读取跟踪事件，并比较每种检索路径的成本。
Assuming I have been on hibernation since 2018-19 time frame, which materials - books, MOOC courses and YT channels would be recommended for me to get started with understanding all the current progress on AI/ML. I am looking for a resource like TeachYourselfCS[1] that can give me structure and roadmap to navigate all the progress/knowledge on the domain. [1] - https://teachyourselfcs.com/ Comments URL: https://news.ycombinator.com/item?id=49966625 Points: 1 # Comments: 0
Kernel knowledge transfer from CUDA to MLX Figure 1: CUDA-to-MLX optimization translation map. CUDA optimization knowledge can be translated into architecture-native MLX strategies rather than copied instruction-for-instruction. We face a new epoch in computing. Hardware is changing rapidly — not just faster GPUs, but a growing range of chips from different vendors, each with its own architecture and often tailored to specific AI workloads. Software is changing just as fast, and AI coding tools now generate in minutes what took months of effort a few years ago. With so much of computing now centered on AI, GPU kernels are a crucial component of its success. These are the low-level programs that run inside the GPU, and writing efficient ones is far from obvious — it takes years of expertise to get right. Transferring a kernel from one vendor’s hardware to another is harder still, and often means rediscovering the same optimizations from scratch. The CUDA ecosystem, for example, has accumulated decades of hard-won kernel expertise: hand-tuned implementations of attention, state space models, and other critical operations representing thousands of engineering hours. Newer hardware ecosystems (Apple Silicon, custom AI accelerators, and others) are growing fast but lack this depth. In this work we ask whether that expertise can be transferred automatically. We built on K-Search , an evolutionary kernel search framework introduced by Cao et al. at Berkeley Sky Lab that uses AI to optimize GPU kernels, and extended it with a backend for MLX — Apple’s machine-learning framework for its own Apple Silicon chips. We developed a novel structured CUDA-to-MLX translation layer that lets K-Search take existing CUDA kernels as a knowledge base and adapt them into high-quality GPU kernels for Apple Silicon, rather than rebuilding from scratch. We show that our approach reaches near-expert level performance on Apple Silicon with 0.97x speedup compared to the native MLX Attention kernel, and up to a 20x prefill speedup over the community mlx-lm implementation on the Mamba SSM kernel; we report the numbers, and how much of the gain comes from the translation layer, in the sections below. Although we focus on MLX kernels for Apple Silicon, the method is not specific to MLX and applies to any ecosystem where CUDA expertise is transferable. Why MLX? Apple’s MLX framework has seen remarkable adoption since late 2023. With Apple Silicon in hundreds of millions of MacBooks and Mac Studios, MLX enables local AI inference without cloud costs. The unified memory architecture makes it especially attractive for mid-sized models (7B–70B parameters on M series chips). Yet beneath this momentum lies a significant gap: many performance-critical kernels that the NVIDIA ecosystem takes for granted: paged attention, optimized SSM scan kernels, fused MoE routing are either absent or naive without hardware-specific tuning. MLX runs models correctly but often leaves significant performance on the table. This gap is what motivates the rest of this post. What is K-Search? K-Search is an evolutionary kernel optimization framework originally developed by our first author Shiyi Cao at UC Berkeley Sky Lab. Given a naive kernel and a hardware specification, it runs an iterative optimization loop: an LLM reasons about which optimizations to try next, a code-writing model generates candidate kernels, and those candidates are compiled and benchmarked on real hardware. Measurements feed back into the search, which keeps refining, pursuing promising directions and dropping dead ends until performance converges. Pseudocode for K-Search via co-evolving world models Algorithm 1: K-Search via co-evolving world models. The search alternates between selecting the most promising action, instantiating and evaluating code until improvement stagnates, and evolving the world model through insert, update, and prune operations. Adapted from Cao et al. (2026) . Search is grounded by a Spec: a domain-specific document encoding hardware rules, optimization patterns, and mathematical constraints which keeps generated code from hallucinating invalid primitives and ensures candidates will actually compile and run efficiently. In our runs, a single model (Gemini 3.5 Pro Preview) plays both roles: it maintains the reasoning state and writes the kernels. The reasoning half is prompted as a “GPU kernel performance engineer” and asked to work through a fixed analysis before proposing anything: classify the kernel (reduction, scan, attention/softmax, …), rewrite the reference computation in canonical form, map out data layout and access patterns, and hypothesize the likely bottleneck (bandwidth, latency, compute, or synchronization) in each runtime regime. Only then does it emit candidate optimizations, each as a single change implementable in one iteration. We call the persistent reasoning state a world model . Rather than a flat list of things to try, it is a decision (prefix) tree: each root→leaf path composes a full optimization plan, and sibling branches are competing alternatives. Every node is scored — an overall_rating in [0, 10], a confidence in [0, 1], and per-node impacts on memory bandwidth, register pressure, and compute/hardware fit — so the search can rank partial plans and expand the most promising ones. The tree persists and grows across rounds: refining an idea adds a child node rather than overwriting its parent, and if the best score fails to improve for a few rounds (a stagnation window) the search backs off to explore an alternative branch. A single node, as it appears mid-run on the attention kernel, looks like this: { "action" : "Replace the threadgroup-memory softmax reduction with a register-only reduction: each SIMD group owns 8 query rows and reduces across lanes with simd_shuffle_xor, removing a threadgroup_barrier." , "difficulty_1_to_5" : 4 , "impacts" : { "memory_bandwidth" : 8 , "register_pressure" : 4 , // risk: spill if Br > 8 "compute_hw_fit" : 9 // SIMD width 32 ; keep tile 8 x 8 }, "overall_rating_0_to_10" : 8 , "confidence_0_to_1" : 0.7 } Listing 1: Example K-Search world-model node. Each candidate optimization records a concrete action, estimated hardware impacts, an overall priority rating, and the model's confidence. Overview of the K-Search loop Figure 2: Overview of K-Search. The framework operates on a Search State $S_t$ structured as a search tree. The tree consists of Closed nodes (blue, visited states with attached program like $x_{12}$) and a Frontier of Open nodes (orange, pending hypotheses like $u_{13}$). The workflow iterates through three phases: (1) Action Selection , where the most promising action node is retrieved from the frontier based on world model estimated priority score $V$; (2) Local Refinement , where a stochastic policy $\pi_{\mathrm{code}}$ samples concrete implementations until stagnation; and (3) World Model Update , where the LLM reasons over the trajectory to update the search tree via Insert (adding new actions), Update (adjusting $V$, e.g., $u_{11}$ dropping from 0.9 to 0.6), and Prune (removing less promising nodes like $u_{10}$). The original K-Search paper evaluated this search strategy on CUDA kernels from FlashInfer. Across GQA decode, MLA decode, MLA prefill, and MoE, K-Search improved more consistently than OpenEvolve and ShinkaEvolve over the same 120-iteration budget. These results establish the search framework we build on here; the remainder of this post asks whether its optimization knowledge can transfer beyond CUDA. K-Search benchmark results compared with OpenEvolve and ShinkaEvolve Figure 3: Main results from the original K-Search paper. Across three runs, K-Search achieves stronger best-so-far search scores, per-workload kernel performance, and speedup distributions than OpenEvolve and ShinkaEvolve on four FlashInfer CUDA kernels. Reproduced exactly from Cao et al. (2026) . Building an MLX backend To bring K-Search to Apple Silicon, we first built a native MLX backend. We implemented a full MLX-specific task adapter for K-Search, including: An MLX task backend in k_search/tasks/ handling kernel compilation and execution on Apple Silicon via MLX’s Metal/C++ APIs. Updated kernel generator prompts for writing and modifying Metal/MLX kernels. MLX-specific benchmarking integration using mlx.core measurement utilities. Translating CUDA expertise to MLX However, the more interesting challenge was not simply running K-Search on MLX. The key insight is that expert CUDA kernels encode decades of optimization knowledge that is transferable to Apple GPU if you can bridge the conceptual gap. Simply handing an LLM a CUDA kernel and asking it to port it is not enough: without deep hardware context, it produces code that is syntactically valid but architecturally wrong (wrong tile sizes, invalid primitives, mismatched memory assumptions). Our translation layer consists of: Concept mapping tables: A structured glossary of CUDA primitives and their MLX/Metal equivalents with hard constraints. For example: __shared__ maps to Metal threadgroup memory but with a hard 32 KB limit (vs. NVIDIA’s 48 KB) warp_reduce maps to MMA (preferred) __syncthreads() becomes threadgroup_barrier(mem_flags::mem_tg) H100’s ~3.35 TB/s HBM3 maps to M3 Max’s ~400 GB/s unified DRAM a bandwidth difference that reshapes which optimizations are worth pursuing. MLX-specific hints and patterns: Concrete code-level patterns for operations with no direct CUDA equivalent, such as register-based row reductions using simd_shuffle_xor in an 8×8 MMA tile layout, or the “exp2 trick” (replacing $exp(x)$ with $exp_2(x \log_2 e)$) for faster softmax on Apple’s fast $exp_2$ hardware instruction. Reusable assertions: Expert kernel behaviors reframed as properties the evolutionary search must preserve, rather than code to copy. Matching expert kernel performance: the Attention kernel We evaluate three configurations of an MLX attention kernel for Apple Silicon: (1) a naive baseline, (2) pure evolution with no additional provided context, and (3) a full context translation layer, which supplies the optimizer with architecture-specific implementation knowledge extracted from high-performance kernels (e.g., FlashAttention-2), letting the evolutionary search reason about implementation strategies rather than starting from a naive kernel. Together, these three configurations let us isolate the exact impact of the translation layer. Performance scaling of the Attention Kernel through stacked optimizations Figure 4: Performance scaling of the Attention Kernel through stacked optimizations. The "Full Context" configuration successfully discovers and implements advanced strategies like double buffering and loop unrolling, achieving near-expert performance. The jump from 0.26× to 0.97× the speed of Apple’s state-of-the-art attention kernel — illustrates how much the translation layer matters. With full context, the evolved kernel independently discovers the key optimizations in FlashAttention 2: threadgroup memory tiling, online softmax, K-transposition for memory access, and the exp2 trick. The last of these replaces every softmax exponential with a base-2 exponential, \[e^x = 2^{x \log_2 e},\] which is exact and lets the kernel use Apple’s fast fast::exp2() hardware instruction directly instead of paying for a base conversion at runtime. A 20× faster prefill: the Mamba SSM kernel To evaluate whether K-Search generalizes beyond attention kernels, we applied it to the state-space model (SSM) kernel used by Mamba. Unlike attention, the computational bottleneck is a recurrent state update rather than a softmax, providing a substantially different optimization challenge. We compare the evolved implementation against the community MLX implementation (mlx-lm) and the PyTorch reference implementation (mamba.py) on an M1 Max. Evaluated on mamba-370m f16, M1 Max 64GB: Metric mlx-mamba (ours) mlx-lm (community) mamba.py Decode 152 tok/s 116 tok/s 40 tok/s Prefill L=512 5,751 tok/s 329 tok/s 1,089 tok/s Prefill L=1024 6,010 tok/s 327 tok/s 1,127 tok/s Prefill L=2048 6,612 tok/s 326 tok/s 1,092 tok/s Prefill L=4096 6,743 tok/s 339 tok/s 1,042 tok/s Table 1: Prefill and decode throughput on mamba-370m (f16, M1 Max 64GB). mlx-mamba (ours) reaches ~20× higher prefill throughput than the community mlx-lm baseline, while decode remains comparable. The ~20× prefill speedup over mlx-lm comes down to one difference: mlx-lm does not implement a parallel scan for the SSM. The state recurrence \[h_t = \bar{a}_t h_{t-1} + \bar{b}_t\] looks inherently sequential, but each step can be written as a pair $(\bar{a}_t, \bar{b}_t)$ under the associative combine \[(a_2, b_2) \circ (a_1, b_1) = \left(a_2 a_1,\ a_2 b_1 + b_2\right),\] which reproduces the recurrence exactly. Because the operator is associative, the whole sequence can be evaluated with a parallel (prefix) scan in $O(\log N)$ dependent steps instead of $O(N)$. mlx-lm skips this and processes tokens one at a time, leaving most of Apple Silicon’s compute idle; our evolved Metal kernel applies the scan and makes much fuller use of GPU throughput. The gain shows up in prefill, where the full sequence is available to scan in parallel, and not in single-token decode, where there is only one new token per step and no scan to parallelize — which is why the decode row is roughly flat while prefill is ~20×. mamba.py is slow on both prefill and decode because it is a PyTorch reference implementation that falls back to CPU or MPS on Apple Silicon, forgoing the hardware-specific optimizations that MLX’s Metal backend makes possible. What’s next? On the two kernels we studied, AI-driven evolutionary kernel search grounded in structured cross-platform translation knowledge reached near-expert performance on Apple Silicon without a team of GPU experts starting from scratch. We do not yet know how far this generalizes, but the result is encouraging. For us the main takeaway is that the bottleneck was not the LLM’s ability to write Metal code, but the quality of the context and constraints we gave it. Our CUDA translation layer converts existing NVIDIA kernel expertise into actionable guidance for Apple Silicon, and lets K-Search’s evolutionary search do the rest. We are actively extending this work in several directions: supporting new architectures, with current efforts focused on developing new kernels for the IBM Spyre AIU and broader hardware targets; adding more kernels such as paged attention and fused MoE routing; and improving integration with the K-Search evolution loop to make translation context even more automatic. Acknowledgements This work was carried out by IBM Research and builds on K-Search from the UC Berkeley Sky Lab ( Cao et al., 2026 ). We welcome collaboration and feedback from the MLX and broader AI systems communities. If you are working on kernel optimization for non-CUDA hardware, we would love to hear from you. Citation @article { cao2026k , title = {K-Search: LLM Kernel Generation via Co-Evolving Intrinsic World Model} , author = {Cao, Shiyi and Mao, Ziming and Gonzalez, Joseph E and Stoica, Ion} , journal = {arXiv preprint arXiv:2602.19128} , year = {2026} } Appendix: Try it yourself The MLX backend is built on top of the open-source K-Search repo, so the results here can be reproduced directly. The steps are: 1. Clone and install git clone https://github.com/caoshiyi/K-Search.git cd K-Search uv pip install openai wandb uv pip install git+https://github.com/caoshiyi/flashinfer-bench-ksearch.git 2. Set your credentials Open the relevant script under scripts/ and set three variables at the top: KSEARCH_ROOT = /path/to/K-Search API_KEY = your-llm-api-key 3. Run kernel search # Optimize Flash Attention on Apple Silicon (world-model mode) bash scripts/mac_flash_attention_wm.sh # Or a Mamba SSM kernel, e.g. the selective scan bash scripts/mamba_selective_scan_fwd_wm.sh Full CLI reference and documentation are in the README.
我们的 Amazon Quick 提示工程系列第 2 部分将逐一介绍各个组件。了解如何为 Amazon Quick Research、Quick Flows、Quick Sight、聊天代理和操作集成设计提示模式，以获得最佳结果，并了解需要避免的常见问题。
Prompt engineering in Amazon Quick shapes how accurately its AI-powered features respond to your requests. Part 1 of a two-part series covers the foundational principles and reusable frameworks (specificity, context-setting, few-shot examples, and the CRISPE framework) for consistent, high-quality results across Amazon Quick.
本技术操作指南基于 Amazon Bedrock Knowledge Bases 构建一个对话式理赔助手，能够回答带有引用的自然语言问题。内容涵盖从 Amazon S3 摄取理赔文档、使用 AgenticRetrieveStream API 进行查询、多轮追问、元数据筛选器，以及上下文 grounding 防护机制。
在 Amazon Bedrock 上运行的 Claude Desktop 如果没有 Web Search，其能力将受限于模型的知识截止时间。本文将逐步介绍如何通过 Amazon Bedrock AgentCore Gateway 将 Claude Desktop 连接到 Web Search，并通过 AWS IAM Identity Center 和 Amazon Cognito 实现基于 JWT 的入站身份验证。
文章 URL： https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5-5 评论 URL： https://news.ycombinator.com/item?id=49874728 得分：23 评论数：1
文章 URL： https://jadidbourbaki.github.io/blog/prompt-lookup-llama-cpp/ 评论 URL： https://news.ycombinator.com/item?id=49859982 得分：25 评论数：2
We found an approach to get Jev-like properties from standard LLMs like GLM-5.3-Flash. The core idea is to craft the input prompt so that the first output token answers the question. This makes it possible to get a decision with a single forward pass. In the blog post, we describe the approach in detail for GLM-5.3-Flash and vLLM. We benchmark this setup against Jev and Laya. We find that our setup is on-par with Jev in terms of accuracy and speed and that it substantially outperforms Laya. Still, in terms of costs per decision, Jev is several x better than our setup. In turn, our setup supports vision inputs. Comments URL: https://news.ycombinator.com/item?id=49857656 Points: 5 # Comments: 1
文章网址： https://www.fmind.dev/articles/agents-md-speaks-unix/ 评论网址： https://news.ycombinator.com/item?id=49833075 得分：10 评论数：2
学习提示基础知识，以及如何编写清晰、有效的提示，以从 ChatGPT 获得更好、更有用的回答。
文章链接： https://vllm.ai/blog/2026-08-23-speculative-decoding-amd-gpus 评论链接： https://news.ycombinator.com/item?id=49596054 得分：9 # 评论数：1
How do you find skills, keep them organized, and make sure they actually work? Do you keep improving them over time? I believe skills will eventually be eating by model capabilities, but until then I'm just looking for a better way to manage things. Comments URL: https://news.ycombinator.com/item?id=49589914 Points: 15 # Comments: 10
文章链接： https://pwning.systems/posts/llm-memory-program-analysis/ 评论链接： https://news.ycombinator.com/item?id=49485416 得分：17 评论数：5
文章网址： https://m-reschreiter.at/en/blog/how-i-cut-80-percent-context-overhead-dynamic-tools 评论网址： https://news.ycombinator.com/item?id=49476278 得分：7 # 评论：0
文章 URL： https://twitter.com/AndrewYNg/status/2090840747738374568 评论 URL： https://news.ycombinator.com/item?id=49407944 点数：8 评论数：0
文章 URL： https://claude.com/blog/maximizing-the-value-of-your-claude-code-sessions 评论 URL： https://news.ycombinator.com/item?id=49300800 积分：169 评论数：106
We’re releasing Spinning Up in Deep RL, an educational resource designed to let anyone learn to become a skilled practitioner in deep reinforcement learning. Spinning Up consists of crystal-clear examples of RL code, educational exercises, documentation, and tutorials.
Cohere、OpenAI 和 AI21 Labs 已经制定了一套初步的最佳实践，适用于任何开发或部署大型语言模型的组织。
我们发布了一份面向在课堂中使用 ChatGPT 的教师指南，其中包括建议提示词、关于 ChatGPT 工作原理及其局限性的说明、AI 检测器的有效性以及偏见。
Put AI to work for your product team
Using ChatGPT to find inspiration for nail art
OpenAI 分享了新的 AI 素养资源，帮助青少年和家长以审慎、安全且自信的方式使用 ChatGPT。这些指南包括经专家审核的建议，涵盖负责任使用、批判性思维、健康边界，以及在情感或敏感话题上支持青少年。
Learn what AI is, how it works, and how tools like ChatGPT use large language models. A clear, beginner-friendly guide to understanding artificial intelligence.
Learn how to use AI responsibly with best practices for safety, accuracy, and transparency when using tools like ChatGPT.
了解如何使用 ChatGPT 进行研究，以收集来源、分析信息，并创建结构化、有引用支持的见解。
深入解析 Codex 智能体循环，展示 WebSockets 和连接作用域缓存如何降低 API 开销并改善模型延迟。
OpenAI 分享了关于第三方 AI 评估的指导，涵盖如何评估前沿系统的模型能力、安全防护措施和有效性。
OpenAI 推出三门 Academy 课程，帮助人们培养实用的 AI 技能，创建可重复的工作流程，并在日常工作中应用智能体。
Learn how Jason Liu uses Codex to preserve context, manage complex projects, and help work continue beyond a single prompt.
OpenAI 首席财务官 Sarah Friar 分享了构建 AI 原生财务职能的五点经验，涵盖从自动化预测到更强的控制以及 AI 投资回报率。