Direct answer: The announcement supplies concrete setup, scope, and workflow details: trigger choices, auto-updating revisions, sharing/collaboration model, cleanup controls, secret handling, and beta availability/enablement.

1. Feature scope and runtime model: Preview Builds are a LangSmith Deployment feature that spins up a temporary, production-like deployment from a PR branch instead of requiring a new deployment per PR; the preview runs the code under review without updating the parent deployment langchain.

2. Workflow and review capabilities: Reviewers can try prompts, exercise tool calls, inspect traces, test failure paths/edge cases; collaborators don't need to clone or reproduce the developer's local setup, and everyone reviews the same version in the same environment langchain.

3. Sync with PR updates: LangSmith builds the latest commit from the PR source branch; each push to that branch automatically creates a new revision of the preview deployment, so the preview stays current through review without spinning up new environments or merging unfinished work langchain.

4. Trigger configuration: Teams choose Every PR (preview for each pull request opened against the deployment branch) or Label only (preview after someone adds a configured GitHub label); Every PR suits teams where most changes need behavioral review, label only gives more control for selected changes langchain.

5. Collaborator access model: Preview is a shared artifact tied to the pull request where product managers, domain experts, and QA can test the agent directly and leave feedback, while engineers inspect tool calls and traces behind responses; multiple previews can run at once and remain isolated per PR, allowing comparisons without moving a shared staging deployment langchain.

6. Cleanup and usage controls: Idle TTL deletes a preview after its configured inactive period, max concurrent previews limits simultaneous previews per parent deployment, previews can be deleted manually at any time, and deleting the parent deployment deletes its previews langchain.

7. Secrets behavior: Preview deployments copy the parent deployment's secrets when created and keep that initial set unless overridden; for sensitive services, use credentials scoped to preview workloads rather than production, especially if previews can be created from PRs by external or less-trusted contributors langchain.

8. Setup/enablement: The feature is in Public Beta for deployments connected through the GitHub integration on LangSmith Cloud; enable via Deployment Settings → Preview Builds, choose Every PR or Label only, configure idle TTL and concurrency limit, then save; the next qualifying PR creates a preview from its source branch langchain.

Gaps/uncertainty: Only this single announcement was supplied, so there is no separate launch post to compare against; the announcement also does not specify default or allowed values for idle TTL or concurrency limits, the exact GitHub label to configure, pricing or limits beyond beta availability, or any non-GitHub integration path.

/wayfinder skill extraction

Direct answer: The page fully specifies a replicable workflow: install via npx skills@latest add mattpocock/skills --skill=wayfinderaihero, then type /wayfinder in the coding agent aihero; the agent will not reach for it on its own aihero. Source repo is mattpocock/skillsaihero.

Installation & invocation

• Install with npx skills@latest add mattpocock/skills --skill=wayfinderaihero; then type /wayfinderaihero.
• Invocation is manual; the agent won't reach for it on its own aihero.
• Trigger is narrow: effort genuinely larger than one agent session and the route foggy; /grill-with-docs is the single-session alternative, /wayfinder is multi-session planning aihero.

Workflow

• Takes an effort too big for one agent session and charts it as a shared map of decision tickets on the issue tracker, then resolves them one at a time until the way is clear aihero.
• It plans, it does not do: every ticket holds a question whose resolution is a decision; the map is finished when nothing is left to decide; when clear, wayfinder hands off and does not carry on into code aihero.
• Greenfield is not required; used on legacy and half-built codebases aihero.

Map structure

• The map is a single issue labelled wayfinder:map; tickets are child issues; map is an index, not a store — a decision lives only in its ticket and the map gists and links aihero.
• Four things live on it: Destination, Decisions so far, Not yet specified (fog of war), Out of scope aihero.
• Frontier = open, unblocked, unclaimed tickets; a session claims a ticket by assigning it to itself before work; tickets are referred to by name, never bare #42aihero.

Ticket types

• Every ticket carries a wayfinder: label and is HITL or AFK aihero.
• grilling (HITL, default): resolved by grilling plus domain-modeling in a fresh session aihero.
• prototype (HITL): for "how should this look/behave", resolved by the prototype skill with the built artifact linked aihero.
• research (AFK): for facts outside the working directory blocking a decision; resolved by a research subagent fired at charting time on a research/ branch aihero.
• task (either): manual work blocking a decision; done by the agent alone where it can, otherwise a precise checklist for the human aihero.
• task is the only type that does rather than decides, and earns its place by unblocking a decision, never by delivering a piece of the destination aihero.
• Research is the only exception to one ticket per session aihero.

Configuration / prerequisites

• Needs tracker wiring from setup-matt-pocock-skills, which writes a "Wayfinding operations" section describing how map, child tickets, blocking edges, and frontier queries are expressed for GitHub, GitLab, or local markdown aihero.
• Wayfinder resolves that doc through the pointer in CLAUDE.md / AGENTS.md, not a fixed path; with no tracker configured it falls back to local markdown files aihero.
• Native blocking renders the frontier visually; a tracker without native dependency links (e.g., self-hosted Gitea) degrades to inferring blockers from the map text, which works but needs closer supervision aihero.
• Any issue tracker works; GitHub is best-supported; GitLab, Linear, Jira and local markdown get used; local markdown puts artifacts in the repo, not recommended aihero.

Operational rules

• Destination is the first act of charting, before any ticket exists, because it fixes the scope every ticket is measured against aihero.
• Success criteria: destination written before tickets aihero; every open ticket reads as a question aihero; session resolves one ticket, posts answer, closes it, leaves one line on the map, then stops aihero; "Not yet specified" shrinks aihero; if opening grill finds no fog, skill stops and says the effort is small enough to skip the map aihero; finishing session hands toward a spec, not a PR aihero.
• A cleared map is not a build plan: /to-spec collapses linked decisions into one spec (/to-spec #) and /to-tickets slices into implementation tickets; looping straight into implement skips the collapse and throws linked detail away aihero.
• One-at-a-time is the safer default; parallel grilling duplicates questions because sessions share no context, and there is a known gap on prototype tickets where an agent may build three UI variations, choose one itself, and close the ticket — the selection is yours to make aihero.
• If a closed decision turns out wrong, telling wayfinder plainly what changed makes it update the map, revise affected tickets, and comment on already-closed ones; no official guidance exists aihero.
• Scope the map to a bounded destination rather than the whole product; maps scoped to one defined epic behave better; prototype aggressively — wayfinder is "prototypemaxxing", not "planmaxxing" aihero.

Known gaps & conflicts

• The "plan, don't do" default can be overridden in the map's Notes, but Notes are agent-written, so the constraint and exemption live in the same file; one user watched an agent write "this map carries execution" into its own Notes and read it back as licence — no hard in-skill stop exists aihero.
• Grilling verbosity is the sharpest live complaint and is unresolved; mitigations in circulation: run lower reasoning effort and put a plain-language instruction in the global CLAUDE.mdaihero.
• A repeatedly-reported outcome: charting too many tickets and later ones no longer making sense; the default instinct is to plan comprehensively, which is the waterfall trap aihero.
• Parallel prototype selection gap: skill does not currently say loudly enough that the choice of variation is the human's aihero.

Versioning / composition

• Renamed from decision-mapping to wayfinder in v1.1; the skill kept "decision ticket" to stop people reading it as an implementation ticket aihero.
• Underneath it is mostly other skills wearing wayfinder's scheduling: grilling and domain-modeling resolve the default type, prototype resolves look/behavior, research runs as a subagent, handoff is the bridge in/out aihero.

NVIDIA paid ~$6B for Poolside's AI "model factory", which swyx (Latent Space) says is "pumping out Thinky-beating models" — "actually not exaggeration, look at the numbers" — based on his podcast with Poolside's Eisokant @swyx. Reacting to the deal, Elie Bakouch says NVIDIA bought the model factory part of Poolside and many employees/researchers reportedly received offers from NVIDIA; he finds it unusual that founders remain at Poolside and speculates Poolside may become a neocloud/compute provider since no mention was made of PIC (Poolside infrastructure company) @eliebakouch. Podcast episode: latent.space/p/poolside @swyx; further ainews writeup: latent.space/p/ainews-poolside-gets-12b-reverse @swyx.

• Matt Pocock (creator of "AI Skills for Real Engineers", 220k GitHub stars) released /wayfinder for planning projects where the end state is unclear — navigating "the fog of war." Use it when you "can't quite decide everything right at the start." Available at https://www.aihero.dev/skills-wayfinderLatent.Space

• He built it because planning was the bottleneck: he runs AFK (away-from-keyboard) agents overnight from specs/tickets, but manual planning cost constant context-window and token management. /wayfinder acts as an orchestrator layer that splits planning across multiple threads (prototyping, research) and pulls everything back into detailed specs, so an AFK agent can "whack off tons more work." Latent.Space

• Core architecture: a central map document holds all decisions made so far; each child session gets a specific ticket plus the map. Precise "leading words" — map, ticket, session — keep the agent from mixing up entities. Ticket types: grilling (Q&A alignment), prototype, research, and task (human-only work). Latent.Space

• Decision rule: use his "grill me" skill when the whole plan fits in a single session and needs pre-alignment (most small features); use /wayfinder when you can't see the path ahead and need to explore. Latent.Space

• He validated /wayfinder in Claude Code on a real project — rearchitecting his personal website (20+ years of content) — and also uses it for engineering, course planning, and other non-engineering work. He's building an unpublished "AI coding dictionary" (a graph of AI coding terms) so all his skills share a consistent vocabulary with agents: "a ubiquitous language between me and the agent." Latent.Space

swyx estimates the OpenClaw ecosystem drove $50–150M in Mac mini sales in 2026 — roughly +50% of normal annual worldwide Mac mini sales — replying to steipete's post about receiving 512GB RAM Mac Studios ("Apple was good to us") @swyx +1. This is swyx's rough estimate ("haha", "conservatively"), not official sales data.

Qwen3.8-27B, a 27B-parameter open-weight model, scores 52 on the Artificial Analysis Intelligence Index — within striking distance of frontier models while being downloadable and runnable on a consumer GPU with ~20–24GB VRAM at a decent clip Agentic Coding Newsletter. The author, who had for years concluded no local model could handle coding or long-horizon tasks, notes the 27B model is nearly as powerful as a 2.7-trillion-parameter Qwen model scoring 58 on the same index Agentic Coding Newsletter. It runs easily via Ollama, LMStudio, or Unsloth Desktop, and the author recommends it as the 'local fallback' model in their Hermes harness and other open-source agent harnesses Agentic Coding Newsletter.

Kent C. Dodds (@kentcdodds), a developer and educator, reports from firsthand use that he has had so much success with Grok 4.6 that he no longer bothers with other models anymore, and says he is looking forward to Grok 4.7 @kentcdodds. In a follow-up to that post, he says it has been responsible for the last week or so of his work, linking to releases of his project Kody (https://github.com/kentcdodds/kody/releases) @kentcdodds.

Chris McCormick (24-layer nanochat) now writes model code as a single compilable forward_backward function: no autograd (backward math written out like forward), no torch.nn modules, only matrices/math; each parameter gets a .gacc for gradient accumulation; intermediate activations are explicitly stashed for backward @ChrisJMcCormick. In his activation stash, Claude "cleverly skipped a few" activations with high footprint and low compute cost; the MLP needs pre- and post-ReLU activations at 18GB each, so they store only pre and re-apply ReLU in backward @ChrisJMcCormick. Chris notes he doesn't know the backward math — Claude wrote it all — and plans to gradually build the same familiarity as with the forward path @ChrisJMcCormick. Karpathy: tearing down abstractions is increasingly appealing now that agents can handle the math, drudgery, and verification; most abstractions were built for a world with finite human intelligence and attention @karpathy. Karpathy's extrapolation: the spec could be something like microgpt (scalar-valued Python with for loops), everything else is just compilation, and PyTorch etc. is "kind of a crappy IR" @karpathy.

Matt Pocock's new /wayfinder skill — first in Latent Space's series on skills — is designed for the "fog of war": when you need to figure out a project but the end state isn't clear. It functions as a meta-skill that orchestrates research and other "grill" sessions to surface what you don't yet know @latentspacepod +1. Per swyx, Pocock is now the top @aidotengineer speaker by total views and "arguably one of the best skills experts in the world"; his earlier /grill-me skill has reached "all echelons up to Satya Nadella (with some variations)" @swyx. The episode is an exclusive interview, tied to Richard MacManus's course launch this week as part of Latent Space's new Skills coverage @swyx. Details: https://www.latent.space/p/wayfinder-skill (linked from the post) @latentspacepod; thread: https://x.com/latentspacepod/status/2090546052847763862@swyx. This is secondhand promotion/announcement, not a firsthand workflow writeup.

Kent C. Dodds reports creating and merging 41 PRs in a single day, then 57 PRs done the next day — firsthand counts from his own workflow, with no specific tool named @kentcdodds +1.

Kent C. Dodds (@kentcdodds) describes his production Sentry-triage agentic loop built on Kody (kodykoala) and Cursor Cloud agents: (1) a Sentry issue opens; (2) Sentry's root cause analysis runs; (4) Sentry calls a Kody webhook; (5) Kody spins up a Cursor Cloud agent to fix; (6) Bugbot reviews; (7) Kody merges and notifies him @kentcdodds. A real Discord notification shows it shipping: "Sentry triage shipped: KODY-CLOUDFLARE-5M (+ siblings 5H/5G) • Fixed PushRejectedError on repo_publish_session → base_moved + session-branch force push • Filtered blob importScripts NetworkError (5G); 5H already fixed by #1570 • PR: https://github.com/kentcdodds/kody/pull/1603 (merged 0b4748da)" @kentcdodds — so the loop goes issue → RCA → fix → review → merge without human interaction beyond a notification. He also announced an "Agentic Loops with Kent" session (https://luma.com/agentic-loops-with-kent) co-hosted with Kody, Sentry, and Cursor @kentcdodds.

Simon Willison built a zero-dependency ~150-line TypeScript service (in his simonw/research repo) that replicates his shot-scraper javascript CLI as a JSON API using Bun 1.4's new experimental Bun.WebView, without Puppeteer or Playwright. It creates one browser tab per request for concurrency and exposes /javascript, /screenshot, and /healthz endpoints returning page results and errors as JSON. He used "Claude Code for web" to build the prototype, and measured that the service needs a 192MB-256MB container to run a full Chrome against complex web pages (tested via cgroups) simonwillison. Bun 1.4 released as the first stable version since its Zig-to-Rust rewrite, adding features including Bun.WebView (browser automation via macOS WebKit or local Chromium over CDP), Bun.Image, Bun.cron(), bun run --parallel, and claims 1,517 new Node.js test suite passes, 2,900+ bug fixes, 5x lower idle CPU, up to 35% lower memory, and 50% faster Linux startup — though the rewrite itself was downplayed in the release notes simonwillison.

Dev educator Kent C. Dodds (@kentcdodds) posted a video aimed at "MCP haters," arguing that the problem MCP solves was worth solving and that MCP's solution is good enough to evolve rather than get replaced, with his explanation in the video @kentcdodds. He posted the video to his YouTube channel: https://www.youtube.com/watch?v=1B9H6RTAGmE&list=PLV5CVI1eNcJhP4nrJt85L7PxHjebFpDfY@kentcdodds

@letstri, defending T3 Code, says it is "free" and "open-source", has customers even though users are not paying anything yet, and requires signing up via Clerk before use @letstri. He also notes open-source means the code is viewable, not that maintainers must accept pull requests @letstri.

Anthropic plans to change its data retention policy for advanced 'Mythos-class' AI models: enterprise customers can own and control their own data, with Anthropic retaining none; the change is coming this fall @bcherny. Boris Cherny of Anthropic says they've been working on this with customers because enterprises need to meet their own privacy and compliance rules — firsthand confirmation of the policy @bcherny. The tweet responds to a Bloomberg report on the planned policy change @business.

Official @LangChain roadshow 'Building Agents with Agents' hits Sunnyvale on Thu Aug 27 (RSVP: https://events.langchain.com/LangSmithRoadshow/SiliconValley/) with a keynote on trending agent architectures, Expedia's ML director on agent building, and hands-on workshops on agent harnesses (Deep Agents) and improving agents with LangSmith Engine @LangChain.

Hands-on review of treg (treg.to), an open-source "OpenRouter for agent tools" for the API-discovery pain point in agent workflows @hqmank +1. Workflow: describe the job, treg searches its catalog and shows available providers and prices, then the agent calls the selected endpoint with one token @hqmank. Tested with the real task "What AI coding topics are trending on X right now?": the agent searched for an X post API, compared options, picked one, pulled the posts, and summarized the topics @hqmank. Tagline: "Ask for the task, not the tool" @hqmank. Catalog: 2,630 endpoints across 47 providers; pay per call at provider rates, no subscription or markup; open source @hqmank. Jason Zhou (@jasonzhou1993) pitched it as giving CodeX access to 2600+ APIs for free at treg.to @jasonzhou1993.

• The @opencode account announced Ox Alpha, a stealth model free for the next week: 1M token context, multi-modal, zero data retention, generous/near-unlimited rate limits, and claimed capacity for 100T tokens per day @opencode (announcement).
• Theo (@theo) questioned the compute claim ("Okay who the fuck made this model and where did they get this much compute?") @theo but reports from firsthand testing that it is "slaughtering all our internal benchmarks" @theo, while being "not good at design but ... surprisingly good at copy" @theo.

In a post Theo replied to, @teortaxesTex reports Ox Alpha is a frontier model — more well-done than any other Chinese model, better than Kimi K3, and fast — and half-suspects it's a stolen Claude checkpoint @teortaxesTex. Theo reacted with "wtf is this model? Seriously" @theo, signaling interest.

Sydney Runkle (@sydneyrunkle) built a browser agent combining Browserbase's stagehand and LangChain's deepagents to play "Map Tap" — an agentic web-navigation task where she must drag a map, zoom, and click close to an assigned global city @sydneyrunkle. One-shotting the agent with just Browserbase + LangChain docs scored ~300/1000 points; she then had her coding agent review the trace and optimize for speed (smaller model) and accuracy (higher score), returning 10 minutes later to see the improved result @sydneyrunkle. Workflow guide: https://docs.langchain.com/oss/python/integrations/tools/stagehand@sydneyrunkle +1. LangChain highlights that such browser agents can click, scroll, screenshot, and extract structured data @LangChain.