<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by The Review Surface on Medium]]></title>
        <description><![CDATA[Stories by The Review Surface on Medium]]></description>
        <link>https://medium.com/@thereviewsurface?source=rss-66b7ba83b889------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*HraM43a3h7jqR3ef9_-Iiw.png</url>
            <title>Stories by The Review Surface on Medium</title>
            <link>https://medium.com/@thereviewsurface?source=rss-66b7ba83b889------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 15:30:16 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@thereviewsurface/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Separate Autofix Evidence From Remediation Approval]]></title>
            <link>https://medium.com/@thereviewsurface/separate-autofix-evidence-from-remediation-approval-3fd27609f231?source=rss-66b7ba83b889------2</link>
            <guid isPermaLink="false">https://medium.com/p/3fd27609f231</guid>
            <category><![CDATA[ai-agent-security]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[coding-agents]]></category>
            <category><![CDATA[ai-coding]]></category>
            <dc:creator><![CDATA[The Review Surface]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 13:01:03 GMT</pubDate>
            <atom:updated>2026-11-18T13:01:03.288Z</atom:updated>
            <content:encoded><![CDATA[<h4>A closed scanning alert answers one question. A merge decision needs its own owner, evidence, and limits.</h4><figure><img alt="A patched code card under a magnifying glass sits beside three evidence tokens, separate from a closed amber gate and a hand holding a blank approval stamp." src="https://cdn-images-1.medium.com/max/1024/1*_nc1FNyjdznbbQjNNUrGRw.png" /></figure><p><em>This article was produced with AI assistance and reviewed before publication.</em></p><p>The draft pull request says the alert is fixed. The service owner asks whether it can merge before lunch. Those statements sound like the same conversation, but they ask different questions.</p><p>This article is about separating those decisions: whether autofix evidence supports a proposed remediation, and whether your team authorizes that exact change to merge. A generated patch is a candidate, not proof that tests ran or that the application is secure.</p><p>Consider an illustrative example. A download service has a code-scanning alert for a user-controlled file path. Autofix changes the handler and supplies a validation summary. The security reviewer wants evidence about traversal. The service owner needs to know whether legitimate downloads still work. Neither should have to guess what the other approved.</p><h3>Read the autofix evidence at its actual scope</h3><p>GitHub’s <a href="https://github.blog/changelog/2026-10-15-agentic-autofix-for-code-scanning-alerts-general-availability/">October 15, 2026 agentic autofix announcement</a> describes an agent that explores relevant files, proposes a fix, reruns CodeQL, and opens a draft pull request. The pull request includes a fix summary, an explanation of why it closes the alert, and validation steps.</p><p>That is a useful place to begin an investigation. It is not a substitute for reading the results. In the example, the first reviewer opens the reported scan rather than copying the summary into an approval comment.</p><p>My proposed operator rule: attach every observation to a revision and a question. Which commit was scanned? Which alert was assessed? What result can another reviewer inspect? When those identifiers are missing, record the evidence as incomplete, even if the explanation sounds convincing.</p><p>The announcement describes CodeQL validation. It does not establish that this particular patch passed your regression tests, preserves authorization behavior, or has no other vulnerabilities. Keep those questions open until you have separate evidence.</p><h3>Follow one download through the proposed change</h3><p>Here is the scenario in more detail. The service serves files beneath a customer’s export directory. The candidate patch normalizes the requested path and adds a containment check. No production repository or patch was tested for this article; the following review is a worked example, not a test report.</p><p>I would ask the reviewer to trace one request from its route parameter to the file read. Where is the customer directory selected? What happens after decoding? Does the handler return before opening a rejected path? These are proposed review questions, not claims about a universal fix.</p><p>Use separate cases for separate promises:</p><ul><li>An attempted escape from the allowed directory should be rejected under the application’s path policy.</li><li>A valid export should remain downloadable by its authorized customer.</li><li>A request for another customer’s export should remain denied.</li><li>An unsupported path form should have an explicit expected result, not an assumed one.</li></ul><p>Specify the expected behavior before running a case. Record actual output, the tested revision, and the relevant environment afterward. A case that was only proposed belongs under missing evidence, not passing tests.</p><p>Path normalization is not the security argument by itself. For this example, I would also ask whether symbolic links and platform-specific path behavior belong in scope. If they do, request targeted cases. If nobody can define the intended policy, return the candidate for clarification instead of inventing an approval standard.</p><h3>Borrow the evaluation questions, not the guarantee</h3><p>GitHub’s <a href="https://github.blog/engineering/fixing-security-vulnerabilities-with-ai/">engineering account of code-scanning autofix</a> describes a 2024 evaluation harness. Its success criteria included removing the alert, introducing no new CodeQL alerts, producing no syntax errors, and preserving repository test outcomes.</p><p>Those are four distinct observations. They give a reviewer better questions than “Did autofix succeed?” They do not prove that a later product version runs that historical harness for every customer patch.</p><p>I would adapt the questions without copying the conclusion. Record the target-alert result, compare other scan findings, inspect build results, and inspect relevant test outcomes. Record each observed result, including pass or fail, or mark it missing. For comparisons, preserve enough information to tell whether the base and candidate used comparable scan configurations.</p><p>Existing tests also need context. If none exercise the download handler’s rejection behavior, a green suite leaves that question unanswered. That is an operator assessment of test relevance, not a claim that a scan or test suite is worthless.</p><h3>Keep two decisions on one review card</h3><p>Copy this artifact into the pull request discussion or your existing change record. It is a proposed team practice, not a GitHub feature or mandatory platform policy. Fill in the fields with evidence from the actual candidate.</p><p><strong>Autofix decision card</strong></p><ul><li><strong>Identity:</strong> repository; pull request; alert identifier; candidate commit; base commit; review date.</li><li><strong>Proposed remediation:</strong> one sentence describing the intended behavior change and affected handler.</li><li><strong>Observed scan evidence:</strong> run link; scanned commit; target-alert result; other findings; configuration differences.</li><li><strong>Observed behavior evidence:</strong> build and test run links; tested commit; relevant cases; expected and actual results.</li><li><strong>Missing evidence:</strong> cases not run; inaccessible logs; unexamined paths; unresolved assumptions.</li><li><strong>Remediation assessment:</strong> supported, return for revision, or insufficient evidence; reviewer; rationale; scope.</li><li><strong>Merge authorization:</strong> pending, approve, or reject; authorized owner; exact commit; required checks; release constraints.</li><li><strong>Recheck trigger:</strong> any later code change or relevant change in the assumptions used for assessment.</li></ul><p>Keep the two decision fields separate even when one person fills both roles. “Supported” means the reviewer accepts a bounded remediation argument. “Approve” means the authorized owner accepts the change under the team’s merge policy. Neither field should silently fill the other.</p><p>For the download example, the reviewer might record that the scan no longer reports the target alert at the candidate commit. The cross-customer test is still missing. The defensible entry is “insufficient evidence,” with merge authorization pending, not “secure because CodeQL passed.”</p><h3>Make disagreement visible before approval</h3><p>Suppose the missing test later passes, but an ordinary export download fails. The security argument and the product regression now point in different directions. Return the patch for revision. A plausible remediation does not make the regression acceptable.</p><p>Conversely, a passing behavior suite with no inspectable scan result leaves the claimed alert resolution unverified. Request the run or rerun the analysis through the team’s established process. Do not turn unavailable evidence into a negative finding, but do not turn it into a pass either.</p><p>A follow-up commit needs a fresh decision about affected evidence. My suggested rule is to reopen both fields until reviewers confirm what remains applicable. Evidence tied to yesterday’s revision must not appear to cover today’s patch without explanation.</p><p>Release timing remains another boundary. An approved merge need not imply permission to deploy immediately. Leave deployment authorization in the existing release process rather than expanding this card into a new incident or release system.</p><h3>Your next decision is smaller than a merge</h3><p>Start with one autofix pull request you already need to review. Do not change branch protections, enable automatic merging, or assign a batch of alerts just to try this method.</p><p>Add the two decision fields and identify one missing observation. Ask the responsible owner for that evidence on the exact candidate commit. The immediate goal is a review another person can reconstruct, not a faster approval or a security guarantee.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3fd27609f231" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Set a Repository Selection Rule Before Copilot Works Across Repos]]></title>
            <link>https://medium.com/@thereviewsurface/set-a-repository-selection-rule-before-copilot-works-across-repos-2941998d6db9?source=rss-66b7ba83b889------2</link>
            <guid isPermaLink="false">https://medium.com/p/2941998d6db9</guid>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[multi-agent-workflows]]></category>
            <category><![CDATA[ai-coding]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[automation]]></category>
            <dc:creator><![CDATA[The Review Surface]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 13:01:02 GMT</pubDate>
            <atom:updated>2026-11-16T13:01:02.868Z</atom:updated>
            <content:encoded><![CDATA[<h4>Choose one write target, name reference-only repositories, and record why the work belongs there before handing it to Copilot.</h4><figure><img alt="A blank chat bubble reaches three repository tracks; a hand operates a locked selector, allowing one teal route while two amber barriers block the others." src="https://cdn-images-1.medium.com/max/1024/1*JOAy-pU592yhmgc52c_I0Q.png" /></figure><p><em>This article was produced with AI assistance and reviewed before publication.</em></p><p>The wrong repository can contain perfectly reasonable code. That is what makes repository selection harder to review than a broken test. A patch may compile, satisfy the chat request, and still put a workaround in a service that should never own the behavior.</p><p>Choose a repository, then hand that choice to Copilot from Slack or Teams. That is a separate decision from deciding <a href="https://medium.com/@thereviewsurface/f34e8542c365">which notifications deserve coding authority</a>. Assume the task has already passed that boundary. The remaining question is where the work belongs, especially when several repositories look relevant.</p><p>My judgment: let Copilot propose a repository, but require a person to confirm the write target from repository evidence. Treat additional repositories as named dependencies, not an expanding workspace. This is a proposed operating rule, not a built-in GitHub control.</p><h3>Official Sources Show Why Selection Needs Its Own Record</h3><p>GitHub’s <a href="https://github.blog/changelog/2026-10-15-copilot-in-slack-and-teams-adds-model-and-repository-updates/">October 15 update</a> describes working across repositories and creating issues and pull requests within a conversation. It also says shared Slack messages and threads can supply context. That supports a distinction between conversational context and repository choice; it does not establish a transaction spanning several repositories.</p><p>The <a href="https://github.blog/changelog/2026-09-25-updates-to-github-copilot-for-slack-and-microsoft-teams/">September 25 update</a> documents default owners and repositories in Slack. A default answers where an interaction can begin. It does not prove that the selected repository owns the requested behavior. The announcement describes a public preview for Copilot Business and Enterprise organizations, with setup and policy prerequisites. Some capabilities were rolling out gradually.</p><p>GitHub’s <a href="https://github.blog/changelog/2026-10-23-turn-notifications-into-code-with-github-copilot-in-teams/">October 23 Teams announcement</a> connects issue notifications with investigation, fixes, and pull-request creation, while retaining team review. It tells users to follow prompts to connect their account and select a repository. That is a handoff path, not evidence that every issue-linked repository is the correct patch location.</p><p>These pages were checked on November 3, 2026. They describe product capabilities, not this proposed routing policy. No live Slack or Teams task was run for this article. Check current availability and behavior in your workspace before adopting the rule.</p><h3>Start With Ownership, Not the Channel Default</h3><p>Use three separate questions when you select the destination.</p><ul><li><strong>Relevance:</strong> Which repository contains evidence needed to explain the symptom?</li><li><strong>Ownership:</strong> Which repository implements the behavior that must change?</li><li><strong>Permission:</strong> Which repository may this task actually edit?</li></ul><p>The answers need not match. An application can reveal a bad response while a service owns the contract. A contract repository can explain an interface without being an approved write target. An accessible repository can still be out of scope.</p><p>I would rank an implementation path plus a named maintainer above a channel default. An issue’s repository is a useful starting hypothesis. A teammate’s shorthand is weaker still. This ranking is operator judgment: the sources do not prescribe an ownership algorithm.</p><p>Avoid making the routing rule depend on confidence language. “Probably the backend” is not a destination. Record the exact owner/repository identifier, the behavior it owns, and the evidence supporting that assignment. If those fields remain unresolved, stop the coding handoff and resolve ownership first.</p><h3>An Operator Scene: The Default Is Relevant but Wrong</h3><p>Consider a fictional team whose Slack channel defaults to example-shop/storefront-web. A support engineer reports that a delivery estimate jumps backward when the customer changes a postcode. The new postcode requires at least five business days under the team&#39;s delivery rule, but the service returns three. The issue already has a clear task and permission to prepare a bounded patch.</p><p>The operator opens the linked issue and sees a frontend screenshot. A teammate suggests clamping the estimate in the browser. That suggestion would make the displayed date look stable. It has not established why the value changed.</p><p>The operator follows the estimate field through three repositories. storefront-web displays the response. delivery-contracts defines the field. promise-service calculates it. These names and observations are invented for the example, not findings from a real incident.</p><p>The maintainer confirms that promise-service owns the date calculation. A small reproduction shows the browser displaying the supplied value without alteration. The operator selects example-shop/promise-service as the only write target. The storefront and contract repositories remain references for the task.</p><p>Someone asks for a quick frontend fallback as well. The operator declines the scope expansion. A second patch might be justified, but it would need a separate ownership decision. The record now explains both the chosen repository and the attractive alternative that was rejected.</p><p>That rejected alternative matters. Without it, the next person may restart the discussion from the screenshot and repeat the same mistaken route. A useful handoff preserves the reason for the destination, not just its name.</p><p>The same exercise applies in Teams: begin from the channel interaction, then independently confirm the owner before handing over the task. I am not claiming that the two apps offer identical repository selectors or default settings.</p><h3>Copy a Repository Selection and Handoff Record</h3><p>Use this plain-text record in the task’s durable home. The example is filled in so each field has a clear purpose. Replace the invented values with inspected evidence. The reference-only rule requires operator review; the text alone cannot enforce access restrictions.</p><pre>Repository selection: delivery estimate / revision 1<br>Origin: Slack thread permalink<br>Task home: issue permalink<br>Observed default: example-shop/storefront-web<br>Selected write target: example-shop/promise-service<br>Behavior owner: delivery-promise maintainer<br>Selection evidence: fictional src/delivery/estimate.ts calculation<br>Reproduction: fictional postcode switch; expected &gt;=5 days, actual 3<br>Allowed change: correct postcode handling in date calculation<br>Reference only: example-shop/storefront-web<br>Reference only: example-shop/delivery-contracts<br>Do not change: storefront display or contract schema<br>Rejected route: browser clamp would mask service behavior<br>Target baseline: insert inspected branch and full commit<br>Target instructions: guidance checked at baseline<br>Completion evidence: fictional postcode_minimum_days test; not run<br>Dependency trigger: contract must change to implement the fix<br>On dependency trigger: stop; request a separate repository task<br>Handoff owner: insert operator name<br>Selection state: operator-confirmed before launch</pre><p>Keep the exact repository identifier even when its short name seems unique. A display name copied from chat leaves room for a mistaken owner or fork. The baseline records what the operator inspected; it is not a claim that a chat integration lets you pin an arbitrary commit.</p><p>Store the reproduction and calculation-path references where the reviewer can retrieve them. “Backend owns it” is not selection evidence. The record should point to the observed data path and the maintainer’s decision, not reproduce a whole channel history.</p><p>If you cannot confirm the destination in the integration’s actual task state, do not send a coding request and hope the prose overrides it. Resolve the target first, or use a separately configured task whose destination can be checked. This is the stop condition that gives the record practical force.</p><h3>Hand Over the Selection, Not the Whole Conversation</h3><p>For a Teams handoff, confirm the app first. In its October 23 announcement, GitHub set November 16, 2026 as the planned retirement date for the legacy app, renamed “GitHub (deprecated).” It directed users to the consolidated GitHub app. That is an announced migration, not a verified completion report. Check current migration guidance before using an old task entry point.</p><p>After confirming the target, keep the coding handoff short. For the fictional case, the instruction could read:</p><pre>Use the confirmed selection record for this task.<br>Prepare a patch only in example-shop/promise-service.<br>Trace the postcode-dependent delivery estimate calculation.<br>Use example-shop/storefront-web as a reference only.<br>Use example-shop/delivery-contracts as a reference only.<br>Do not add a browser clamp or change the contract schema.<br>If a contract change is necessary, stop and report that dependency.<br>Return the repository, actual baseline, changed paths, and tests.</pre><p>This example is ordinary task text, not a documented command syntax. Check the app’s selected destination before sending it. Compare the reported destination with the record afterward. Neither step should depend on the agent silently choosing the same meaning for an abbreviated repository name.</p><p>A late message can be useful evidence without becoming a revised selection. In the example, the frontend fallback request belongs in the discussion. It does not replace the confirmed write target. The operator must issue a new record revision if the team accepts a different destination.</p><p>Preserve repository-specific guidance at the receiving end. A convention discussed for the storefront does not automatically belong in the service patch. Ask the receiving task to identify the guidance it used, then compare that account with the selected repository. This check is my workflow recommendation, not a capability promised by the changelog.</p><h3>Split a Dependency Into a Second Task</h3><p>Suppose investigation reveals that the existing contract cannot express the corrected estimate. The first task should return a dependency report rather than quietly editing delivery-contracts. Include the needed contract behavior, the blocking example, and the affected consumer.</p><p>The operator then selects a repository for the contract change. A second record names its owner, scope, and completion evidence. Link the two records and state which result the service task needs before it can continue.</p><p>I prefer this split even when a conversation can span repositories. It gives each maintainer a reviewable unit and exposes ordering. It does not require a new chat channel for every repository. The separation is between task destinations and evidence, not necessarily between conversations.</p><p>Do not infer that creating multiple pull requests makes them an atomic delivery. The retrieved announcements do not establish synchronized merges, shared rollback, or cross-repository test guarantees. If a change needs coordinated deployment, use the team’s existing release process. A repository-selection record is not a replacement for it.</p><h3>Recheck the Route After an Interruption</h3><p>A resumed task needs a small routing check, not a retelling of the entire incident. My proposed check compares the destination and ownership evidence with the current task state.</p><ul><li>Does the task still name the confirmed owner/repository pair?</li><li>Does its actual baseline differ from the inspected baseline?</li><li>Has the issue gained a dependency that changes the owner?</li><li>Has someone revised the allowed write target in the durable record?</li></ul><p>An ordinary baseline change is not automatically a failure. It means the operator should decide whether the selection evidence still applies. A renamed service boundary or changed contract could invalidate the route even if the symptom sounds unchanged.</p><p>If the destination changes, save the new decision before continuing. Do not rewrite revision 1 to make the final patch appear to have followed it. The point is to make changes of direction visible, including reasonable ones.</p><h3>Review the Destination Before the Diff</h3><p>Begin review by comparing the actual changed repository and paths with the selection record. Then ask whether the patch fixes behavior owned by that repository. A correct destination can still contain a misplaced workaround.</p><p>In the example, a service change with a focused postcode test fits the route. A storefront clamp does not, even if a screenshot looks better. A schema edit means the dependency stop was missed. These outcomes can be judged without claiming that the fictional patch was executed.</p><p>The record earns its cost when it helps someone reject a plausible wrong destination. If reviewers only copy its fields into a pull request, it adds paperwork rather than judgment. Keep the ownership evidence short enough to inspect and specific enough to challenge.</p><h3>Your Next Decision: Test One Ambiguous Route</h3><p>Choose one existing task with two plausible repository destinations. Before asking Copilot to code, have its maintainer fill in the selection record. Compare the channel default, the issue location, and the implementation owner. Save the reason for rejecting the second destination.</p><p>Proceed with a bounded single-repository task only when you can verify the actual destination. If ownership remains disputed, leave the handoff incomplete. That is a useful result, not a routing failure to hide.</p><p>My rule is deliberately stricter than “work wherever the conversation leads.” A conversation can gather evidence from several places. A coding task should inherit a confirmed destination, and every extra write target should earn a separate decision.</p><h3>Sources</h3><ul><li><a href="https://github.blog/changelog/2026-10-15-copilot-in-slack-and-teams-adds-model-and-repository-updates/">Multi-repository support and other improvements for GitHub in Slack and Teams</a></li><li><a href="https://github.blog/changelog/2026-09-25-updates-to-github-copilot-for-slack-and-microsoft-teams/">Updates to GitHub Copilot for Slack and Microsoft Teams</a></li><li><a href="https://github.blog/changelog/2026-10-23-turn-notifications-into-code-with-github-copilot-in-teams/">Turn notifications into code with GitHub Copilot in Teams</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2941998d6db9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Add a Model-Availability Check Before Scheduled Copilot Runs]]></title>
            <link>https://medium.com/@thereviewsurface/add-a-model-availability-check-before-scheduled-copilot-runs-c4296aaac57b?source=rss-66b7ba83b889------2</link>
            <guid isPermaLink="false">https://medium.com/p/c4296aaac57b</guid>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[agent-reliability]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[The Review Surface]]></dc:creator>
            <pubDate>Fri, 13 Nov 2026 13:01:03 GMT</pubDate>
            <atom:updated>2026-11-13T13:01:03.357Z</atom:updated>
            <content:encoded><![CDATA[<h4>A small preflight file that stops an unattended Copilot job, or switches it on purpose, when its pinned model retires.</h4><figure><img alt="Hand-drawn clock and calendar feeding a preflight gate, with one path ending at a stop mark and another detouring through a lock to a flagged review card." src="https://cdn-images-1.medium.com/max/1024/1*nigt_4u5AmN_5C1ebgPTVw.png" /><figcaption>A scheduled run pauses at a preflight gate: a crossed-out calendar day and a locked switch decide whether it stops or takes a marked fallback path.</figcaption></figure><p><em>This article was produced with AI assistance and reviewed before publication.</em></p><p>It is Friday, November 13. A scheduled GitHub Actions workflow runs Copilot CLI with a pinned model every Monday at 02:00. It reads the open dependency alerts, drafts a triage note, and opens a pull request with the safe bumps. The job config names one model: GPT-5.6 Terra. Nobody has touched that line in months.</p><p>The next run lands on Monday, November 16. That is the exact date GitHub lists for deprecating GPT-5.6 Terra across all Copilot experiences. (GitHub says “deprecate”; this article uses “retire” for the same cutoff.) Nobody is awake at 02:00 to notice what the job does instead.</p><p>This is a preflight check for unattended Copilot runs, not a model comparison or a guide to writing model policy. It answers one question before the run starts: is the pinned model still available to this account, and if not, should the run stop or switch on purpose? The example uses GitHub Actions, but the check works with any scheduler.</p><h3>Four Changelog Posts That Set the Cutoffs</h3><p>Three GitHub changelog posts give the check its facts, and a fourth covers policy. Each one has a different job.</p><p>The <a href="https://github.blog/changelog/2026-10-15-upcoming-deprecation-of-selected-github-copilot-models-in-mid-november/">mid-November deprecation notice</a> is the warning. It says Claude Opus 4.8, Claude Opus 5, and GPT-5.6 Terra will be deprecated on November 16, 2026, across all Copilot experiences, including Copilot Chat, inline edits, ask and agent modes, and code completions. It names suggested alternatives: Claude Opus 5.5 for both Opus models, and GPT-6.1 Sol or GPT-6 Luna for GPT-5.6 Terra.</p><p>It also carries an exception. Claude Opus 4.8 stays available to individual Copilot subscribers on annual plans. The same model name can be retired for one account and live for another.</p><p>The <a href="https://github.blog/changelog/2026-10-19-github-copilot-models-deprecated-on-october-19-2026/">October 19 deprecation notice</a> is the proof that the warning turns into a cutoff. On that date GitHub deprecated Gemini 3.7 Flash, GPT-5.5, GPT-5.4, GPT-5.4 mini, GPT-5 mini, and Grok 4.5 across “most” Copilot experiences, where the November notice says “all”. The post notes these were announced on September 18, about a month ahead. A job that pinned GPT-5.4 mini needed its owner to read that notice in time.</p><p>The <a href="https://github.blog/changelog/2026-10-26-gpt-6-1-terra-in-github-copilot/">GPT-6.1 Terra release note</a> is the tempting shortcut. GPT-6.1 Terra is generally available to Pro, Pro+, Max, Business, and Enterprise users. GitHub says it solved more terminal and C# tasks than GPT-5.6 Terra in early testing, and describes it as lower cost than GPT-6.1 Sol. But it is not on the suggested-alternative list for GPT-5.6 Terra, its rollout is gradual, and it is billed at provider list pricing under usage-based billing.</p><h3>Admin Policy Can Switch a Model Off Early</h3><p>Retirement is only one way a model disappears. The other is your own admin settings.</p><p>The November notice says suggested alternatives are turned on automatically for Copilot Business and Enterprise, unless an administrator has turned off the global default or explicitly disabled the model. The GPT-6.1 Terra note says the same about new models. So a fallback that exists in the product can still be off for your organization.</p><p>GitHub now exposes this through the <a href="https://github.blog/changelog/2026-10-19-copilot-model-policy-api-for-enterprise-orgs-and-teams/">Copilot model policy API</a>. GET and PATCH endpoints are generally available at four levels: enterprise, enterprise teams, agent apps, and organization. A preflight can read the policy at the level that governs the job instead of guessing.</p><h3>The Preflight File</h3><p>Keep the check next to the job, in a small file the job reads before it calls Copilot. The format below is operator judgment, not a GitHub schema.</p><pre>job: weekly-dependency-triage<br>pinned_model: GPT-5.6 Terra<br>retire_date: 2026-11-16          # Oct 15 changelog<br>warn_days: 14<br>fallback_model: GPT-6.1 Sol      # listed suggested alternative<br>policy_read: GET /orgs/{org}/copilot/model-policies<br>on_warn_window: run_and_open_issue<br>on_retired: fail_closed<br>on_policy_disabled: fail_closed<br>fallback_allowed_for: triage_note_only<br>fallback_needs: policy_enabled<br>fallback_output: label_needs_review</pre><p>The policy_read step assumes the GET response exposes a per-model enabled state. Confirm the field name in the REST reference before you wire it.</p><p>GitHub gives a date, not a time. Treat the whole deprecation date, in UTC, as retired, so on_retired triggers on or after November 16.</p><p>The rules read top to bottom. Inside the warning window, run but open an issue for the owner. On or after the retire date, or if policy disables the pinned model, stop. One exception: the read-only triage note may switch to the named fallback, and only if policy enables it.</p><h3>Three Mondays of the Triage Job</h3><p>Here is how three Mondays would have gone if the check had existed from November 2. The job and schedule are illustrative.</p><ul><li><strong>November 2.</strong> The retire date is 14 days away. The check would pass, the job would run, and it would open an issue that names the job and the retire date.</li><li><strong>November 9.</strong> Still inside the window. The issue exists, so the check would only comment on it. The owner would have two reminders and a working run.</li><li><strong>November 16.</strong> The retire date has arrived, and the check counts the whole UTC day. The job would not call Copilot with GPT-5.6 Terra.</li></ul><p>On that last Monday the job would split. The pull request step would fail closed, because it writes to the repository. The triage note step would read the org model policy for GPT-6.1 Sol. If the model is enabled, the note would run on it and carry a needs-review label, since nobody has checked that model against this job.</p><p>If an admin turned off the global default and never enabled GPT-6.1 Sol, the note would stop too. The failure message would name the model, the date, and the policy result, so the owner can fix it with one edit.</p><p>Neither outcome is silent. That is the whole point of the check.</p><h3>Which Runs May Switch Models</h3><p>The sources say which models retire and which alternatives GitHub suggests. They do not tell you which runs may switch models. That call is yours.</p><p>Operator judgment, as a starting rule:</p><ul><li>Fail closed for runs that write: open pull requests, push branches, or edit issues.</li><li>Allow a fallback for read-only steps, such as a triage note, but only to a model you listed in advance.</li><li>Pick fallbacks from GitHub’s suggested-alternative list first, then confirm policy enables them.</li><li>Treat a newer model such as GPT-6.1 Terra as a <a href="https://medium.com/@thereviewsurface/run-a-task-baseline-before-you-switch-copilot-to-gpt-6-1-terra-f8c9e8d4816a">planned change with its own review</a>, not an automatic fallback.</li></ul><p>The last rule matters. GPT-6.1 Terra may be a good choice later. But its rollout is gradual, it is billed at provider list pricing under usage-based billing, and GitHub did not name it as the replacement. A 02:00 run is the wrong place to adopt it.</p><h3>Blind Spots in a Hand-Kept File</h3><p>The changelog posts do not say what a scheduled run does when it requests a retired model. It may error, or a client may pick another model. The preflight exists so you never rely on that behavior.</p><p>The retire dates in the file are copied by hand from changelog posts. If GitHub announces a new deprecation and nobody updates the file, the check passes with stale facts.</p><p>The policy API changelog lists endpoints but does not describe the response fields. That is why the policy_read field name needs checking first.</p><p>Account type changes the answer. The Claude Opus 4.8 exception means one check result does not transfer between an annual individual plan and a Business org.</p><p>GitHub’s claim that GPT-6.1 Terra solved more tasks comes from its own early testing. It says nothing about your triage job.</p><h3>Before Next Monday’s Run</h3><p>Open every scheduled workflow file that calls Copilot and search for a model name. For each hit, check it against the two deprecation tables. Write the retire date and a fallback beside it, even as a comment. That list is the first version of your preflight file.</p><h3>Sources</h3><ul><li><a href="https://github.blog/changelog/2026-10-15-upcoming-deprecation-of-selected-github-copilot-models-in-mid-november/">Upcoming deprecation of selected GitHub Copilot models in mid-November</a></li><li><a href="https://github.blog/changelog/2026-10-19-github-copilot-models-deprecated-on-october-19-2026/">GitHub Copilot models deprecated on October 19, 2026</a></li><li><a href="https://github.blog/changelog/2026-10-26-gpt-6-1-terra-in-github-copilot/">GPT-6.1 Terra in GitHub Copilot</a></li><li><a href="https://github.blog/changelog/2026-10-19-copilot-model-policy-api-for-enterprise-orgs-and-teams/">Copilot model policy API for enterprise, orgs, and teams</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4296aaac57b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Test Model Policy Precedence Before You Automate Copilot Access]]></title>
            <link>https://medium.com/@thereviewsurface/test-model-policy-precedence-before-you-automate-copilot-access-5a4c3f2ff1d9?source=rss-66b7ba83b889------2</link>
            <guid isPermaLink="false">https://medium.com/p/5a4c3f2ff1d9</guid>
            <category><![CDATA[ai-governance]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[automation]]></category>
            <dc:creator><![CDATA[The Review Surface]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 13:01:03 GMT</pubDate>
            <atom:updated>2026-11-11T13:01:03.312Z</atom:updated>
            <content:encoded><![CDATA[<h4>A test matrix for enterprise, team, app, and organization model policies, run before a scripted PATCH changes who can pick a model.</h4><figure><img alt="Hand-drawn diagram of four stacked policy layers with a token falling through them, dashed arrows marking stops, a grid of blank test cards with checks and warnings, and a key with a dashed arrow looping back to the top layer." src="https://cdn-images-1.medium.com/max/1024/1*h-L1ZHqHIQny6tBa_ka78g.png" /><figcaption>One model setting dropped through four policy layers, with a test grid recording where it stops before any change is automated.</figcaption></figure><p><em>This article was produced with AI assistance and reviewed before publication.</em></p><p>The change ticket is short: give the platform team GPT-6.1 Terra, and nobody else. The script is ready. It sends one PATCH to the enterprise team endpoint and exits on a success response.</p><p>Then a reviewer asks two questions. What does the enterprise level say about Terra right now? And if an organization owner already disabled it, which setting wins? Nobody on the ticket can answer from the docs they cited. The script would succeed either way, and the success response would prove nothing about who can pick the model.</p><p>This is a guide to testing model policy precedence before you script it, not a reference for the model policy API or a review of global feature defaults. The goal is one artifact: a test matrix that turns “which level wins” from a guess into recorded results.</p><h3>Two Facts the Changelogs Give You</h3><p>GitHub’s <a href="https://github.blog/changelog/2026-10-19-copilot-model-policy-api-for-enterprise-orgs-and-teams/">model policy API changelog</a> makes GET and PATCH endpoints generally available at four levels:</p><ul><li>Enterprise: /enterprises/{enterprise}/copilot/model-policies</li><li>Enterprise teams: /enterprises/{enterprise}/teams/{team_slug}/copilot/model-policies</li><li>Agent apps: /enterprises/{enterprise}/copilot/apps/model-policies</li><li>Organization: /orgs/{org}/copilot/model-policies</li></ul><p>The same note states one structural rule: “Enterprise policies can delegate model control to organizations in organization mode, or to teams and apps in enterprise teams mode.” So the enterprise level decides who may decide. The note does not say whether delegation is set per model or for the whole mode. Confirm that in the REST reference before you plan any PATCH around it.</p><p>The <a href="https://github.blog/changelog/2026-10-26-gpt-6-1-terra-in-github-copilot/">GPT-6.1 Terra release note</a> adds the second fact. Copilot Business and Enterprise administrators manage Terra through the model policy. Under default model enablement, new models are enabled automatically unless an administrator turned off the global default or explicitly disabled that model. Rollout is gradual, and Terra is billed at provider list pricing under usage-based billing.</p><p>That matters for the ticket. If the global default is on, Terra may already be enabled for every eligible user before the team PATCH runs.</p><h3>Questions the Sources Leave Open</h3><p>The sources do not say what happens when the enterprise enables a model and an organization disables it. They do not say whether a team setting matters while the enterprise runs in organization mode. They do not say whether an app policy follows the team, the organization, or neither.</p><p>The changelog links to GitHub’s docs on managing model availability and the REST reference. Read the page for the mode your enterprise uses and write its rules down as expected results. Then test them. Docs can change between a read and a run, and your enterprise may be in a different mode than you assume.</p><p>The <a href="https://github.blog/changelog/2026-10-22-global-default-for-copilot-features-generally-available/">global default changelog</a> covers settings on “Features &amp; clients” and “MCP servers in Copilot”. It does not claim to govern model policies, so do not borrow its rules for models.</p><h3>The Precedence Test Matrix</h3><p>Run this in a test organization or sandbox enterprise, with two test accounts: one inside the target team and one outside it. For each case, record the setup, the PATCH, the GET response at every level, and what each test account sees in the model picker.</p><ul><li><strong>Case 1, baseline:</strong> GET all four levels before any change and save the JSON. Also record the global default from Copilot settings, since no source says a model policy GET returns it. This is your rollback target.</li><li><strong>Case 2, unconfigured model:</strong> Leave the target model unconfigured. Check both accounts. Repeat with the global default turned off, if you are allowed to change it in the sandbox.</li><li><strong>Case 3, enterprise disabled, team enabled:</strong> Disable the model at the enterprise level, then PATCH the team to enable it. Does the inside account get the model?</li><li><strong>Case 4, enterprise delegates, team enabled:</strong> Set the enterprise policy to delegate model control to teams and apps, in the form the REST reference describes, then PATCH the team. Record whether the inside account gets the model and the outside account does not.</li><li><strong>Case 5, wrong mode:</strong> Switch the sandbox enterprise to organization mode, then PATCH the team endpoint. Record the response code and whether anything changes for either account. This case requires a mode switch; skip it if you cannot switch modes in a sandbox.</li><li><strong>Case 6, enterprise enabled, org disabled:</strong> Enable at the enterprise level, then PATCH the organization to disable. Record which setting each account follows.</li><li><strong>Case 7, agent app:</strong> With model control delegated to teams and apps, PATCH the app endpoint. Check whether the app can use the model and whether either human account changed.</li><li><strong>Case 8, rollback:</strong> PATCH every level back to the Case 1 JSON. GET again and diff against the baseline.</li></ul><p>Mark each case as matches docs, contradicts docs, or undocumented. Only cases that match docs should become assumptions inside automation.</p><h3>Terra for One Team: A Hypothetical Run</h3><p>Take the ticket from the opening as a worked example. The results below are hypothetical, not a recorded test. The enterprise is in enterprise teams mode, and the goal is Terra for one team.</p><p>Case 1: Copilot settings show the global default is on, and the GET shows Terra unconfigured. Per the Terra release note, Terra would then be enabled automatically for users on eligible plans, subject to the gradual rollout. Case 2 confirms it: the outside account already sees Terra. The team PATCH might have changed nothing visible, and the ticket’s real goal was the opposite of current state.</p><p>So the plan changes. Step one is an enterprise PATCH that delegates model control to teams and apps, in whatever form the REST reference specifies. Step two is the team PATCH. Case 4 then checks that the inside account sees Terra and the outside account does not.</p><p>Case 7 matters because the ticket said nothing about apps. If the app endpoint has its own setting, an agent app may lose Terra after the enterprise change. The matrix catches that before users do.</p><h3>Decision Rules Before the PATCH Goes Into Automation</h3><p>These rules are operator judgment, not GitHub guidance:</p><ul><li>Script a level only after its matrix cases match the docs you cited.</li><li>Make the script GET every level before and after each PATCH, and store both responses.</li><li>Treat a success response as “request accepted”, not as “access changed”. Verify with a picker check by a test account.</li><li>Fail the run if the post-change GET differs from the expected JSON.</li><li>Rerun Cases 3 to 7 when GitHub announces a change to model policy modes or defaults.</li></ul><h3>When the Sandbox Lies</h3><p>The matrix proves what one sandbox did on one day. It does not prove production behavior if your production enterprise uses a different mode.</p><p>Picker checks can lag. The Terra note says rollout is gradual, so a missing model may mean rollout timing, not policy. Record the time of each check and repeat a failed one before calling it a precedence result.</p><p>The matrix does not cover cost. Enabling a model billed under usage-based billing is a budget decision as well as an access decision.</p><p>Finally, the sources here are changelog entries. They state what shipped and link to docs. They are not a full specification of precedence.</p><h3>Snapshot Four Levels Before Any PATCH</h3><p>Before you write any PATCH, run GET against the enterprise, one team, the apps endpoint, and one organization. Save the four responses and the global default setting in your change ticket with the date. That snapshot is Case 1, and it is also your rollback plan.</p><h3>Sources</h3><ul><li><a href="https://github.blog/changelog/2026-10-19-copilot-model-policy-api-for-enterprise-orgs-and-teams/">Copilot model policy API for enterprise, orgs, and teams</a></li><li><a href="https://github.blog/changelog/2026-10-26-gpt-6-1-terra-in-github-copilot/">GPT-6.1 Terra in GitHub Copilot</a></li><li><a href="https://github.blog/changelog/2026-10-22-global-default-for-copilot-features-generally-available/">Global default for Copilot features generally available</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5a4c3f2ff1d9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Normalize Seat Mix Before You Benchmark Copilot Impact]]></title>
            <link>https://medium.com/@thereviewsurface/normalize-seat-mix-before-you-benchmark-copilot-impact-06bee52aab00?source=rss-66b7ba83b889------2</link>
            <guid isPermaLink="false">https://medium.com/p/06bee52aab00</guid>
            <category><![CDATA[engineering-metrics]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[engineering-management]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[github-copilot]]></category>
            <dc:creator><![CDATA[The Review Surface]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 13:01:02 GMT</pubDate>
            <atom:updated>2026-11-09T13:01:02.150Z</atom:updated>
            <content:encoded><![CDATA[<h4>A worksheet for reading the Copilot industry comparison against your own cohorts, clients, and model selection modes.</h4><figure><img alt="Hand-drawn balance scale: on one side a tray of seat tokens sorted into three colored cohorts, on the other a peer stack half hidden behind fog and a question mark." src="https://cdn-images-1.medium.com/max/1024/1*dSLq0nz24wHRwx8QVTOgxg.png" /><figcaption>Your seats are sorted into cohorts before they are weighed against a peer stack you can only partly see.</figcaption></figure><p><em>This article was produced with AI assistance and reviewed before publication.</em></p><p>The quarterly review deck has one new slide. It is a screenshot of the industry comparison in the Copilot impact dashboard. Your share of agent-first or multi-agent users sits below the peer median for your company size and industry. Someone asks the obvious question: why are we behind?</p><p>You know things the screenshot does not show. A group of contract reviewers holds Copilot seats but mainly touches code review. Thirty new hires got seats in the last ten days of the window. The data team runs Copilot through OpenCode instead of an IDE. None of that appears next to the peer median.</p><p>This is a guide to reading an industry benchmark against your own seat mix, not a guide to raising your agentic adoption number. The goal is a comparison you can defend in the meeting, with composition differences written down before anyone reads the gap as a behavior problem.</p><p>A word on the title. In this article, normalize does not mean recalculating your score into a true like-for-like number. The peer group’s mix is hidden, so that is not possible. It means describing your seat, client, and model selection mode mix at cohort level, then adjusting the claim you make so the comparison is honest about what differs.</p><h3>Read the Benchmark Rules Before You Quote the Gap</h3><p>Everything in this section is a source claim. Operator judgment is labeled as such further down.</p><p>The <a href="https://github.blog/changelog/2026-10-22-industry-comparisons-in-the-copilot-impact-dashboard/">industry comparisons changelog</a> describes two benchmark areas. One is the percentage of your users who are agent-first or multi-agent. The other compares the pull request merge rate of agentic users with that of nonagentic users.</p><p>Each score is ranked against the peer median for the 28-day reporting period. As the peer group grows, it is also ranked against the top decile. You pick a company size band and one of ten industries, then switch between your industry and all industries.</p><p>A few details matter for any comparison:</p><ul><li>Participation is opt-in and disabled by default. One policy controls both contributing data and seeing comparisons.</li><li>If your industry peer group is too small, the comparison widens to all industries for your company size, and the dashboard labels the peer group it used.</li><li>Soon after launch, you might see only the median, a broader peer group, or no ranking at all.</li><li>Rankings are not shown when your own score cannot be calculated, such as when every user is already agent-first or multi-agent and no nonagentic baseline exists.</li><li>Comparisons refresh daily and appear only in the dashboard. They are not in the usage metrics API, NDJSON exports, or downloads.</li><li>With data residency on GitHub Enterprise Cloud, you are compared only with participants in the same region.</li><li>Organizations owned by an enterprise participate through their enterprise. Enterprises used only to assign Copilot Business licenses cannot participate, and the Copilot usage metrics policy must be enabled.</li></ul><p>The dashboard-only point is the practical constraint. You cannot pull the benchmark into a script and join it with your own cohort data. Any normalization happens beside the screenshot, by hand.</p><h3>Why Seat Mix Moves the Number Before Behavior Does</h3><p>A percentage has a denominator. The changelog says “percentage of your users” and does not spell out which users count or how peer populations are built. Treat that as an open question for the dashboard documentation, not a detail to guess.</p><p>Operator judgment: whatever the exact definition, the people inside your denominator shape the score as much as their habits do. Three kinds of seats deserve a note before you compare:</p><ul><li>Seats with a narrow job. Reviewers, support engineers, or contractors who mainly use code review may never become agent-first. That can be the right outcome for them.</li><li>Seats that arrived mid-window. A 28-day period that includes a large onboarding wave mixes brand-new users with experienced ones.</li><li>Seats outside your team. Because enterprise-owned organizations participate through the enterprise, the score may describe a wider population than the group you manage.</li></ul><p>The peer median carries its own seat mix too, and you cannot see it. That is the core asymmetry. You can describe your composition in detail and the peer group’s composition not at all.</p><h3>Client Mix and Model Selection Are Hidden Variables</h3><p>Two recent usage metrics updates help you describe your side of the comparison. Neither describes the peers.</p><p>The <a href="https://github.blog/changelog/2026-10-23-usage-metrics-api-adds-usage-from-tools-like-opencode/">usage metrics API update for tools like OpenCode</a> added a totals_by_client array. Each entry names a client, such as opencode, claude_code, codex, copilot_cli, cloud_agent, code_review, vscode, or jetbrains. It reports successful model requests, sessions, token usage, and a per-model breakdown. Each model entry carries a model_selection_mode: user_selected, auto, or product_selected, with other for modes not yet reported individually and unknown for values that cannot be normalized.</p><p>Source details that change how you read client mix:</p><ul><li>request_count counts model calls, not prompts. One prompt can trigger several calls.</li><li>Client identity is a best-effort grouping based on the integration ID sent with each request, not a verified identity.</li><li>Code review and cloud agent requests report product_selected, because the product chooses the model. Code review models are reported as unknown.</li></ul><p>Operator judgment: if a large slice of your traffic is product_selected from code review, much of your Copilot activity is product-driven rather than chosen by developers. That tells you something about how your seats are used. It does not tell you whether those users count as agentic in the benchmark. The changelog does not connect the two, so neither should your slide.</p><p>The <a href="https://github.blog/changelog/2026-10-22-custom-skills-agents-and-mcp-servers-in-usage-metrics-api/">customization metrics update</a> adds a second caution. Its named entries come from client telemetry, which can undercount when clients are outdated or telemetry is blocked. GitHub says to use them for trends and adoption, not exact accounting. Apply the same restraint to any client-side signal you place next to a benchmark.</p><h3>Fill In the Seat-Mix Worksheet Before the Meeting</h3><p>Copy this list into the notes field under the benchmark slide. Fill it in before the meeting, not during it.</p><ul><li><strong>Benchmark snapshot:</strong> date captured, 28-day window end, metric shown, your score, peer median, and top decile if shown.</li><li><strong>Peer group used:</strong> company size band, industry selected, and whether the dashboard says it widened to all industries.</li><li><strong>Denominator definition:</strong> the documented meaning of “users” for this metric, with a link. Write “unconfirmed” if you have not checked.</li><li><strong>Participation scope:</strong> organization or enterprise, and whether data residency limits peers to one region.</li><li><strong>Cohort split:</strong> your users grouped by job, such as core engineers, reviewers or contractors, and recent onboarding.</li><li><strong>Onboarding inside the window:</strong> seats assigned during the 28 days, and how many arrived in the last ten days.</li><li><strong>Client mix:</strong> the top clients by request_count from totals_by_client, with a note that requests are not prompts. In the aggregated 28-day reports, totals_by_client sits inside each day_totals entry, so sum across the days yourself.</li><li><strong>Selection mode split:</strong> share of requests that are user_selected, auto, product_selected, other, and unknown.</li><li><strong>Merge-rate baseline:</strong> how many nonagentic users form the comparison group, and who they are.</li><li><strong>Known telemetry gaps:</strong> clients or teams where reporting may undercount.</li><li><strong>Comparability call:</strong> comparable, comparable with caveats, or not comparable yet.</li><li><strong>One-sentence statement:</strong> the exact claim you will say out loud.</li></ul><p>The worksheet does not change the dashboard number. It changes what you are allowed to claim from it.</p><h3>Split a 25 Percent Score Into Cohorts Before Reacting</h3><p>Every number in this section is invented to show the method. None comes from GitHub or from a real organization.</p><p>Say the dashboard shows 25 percent of your users as agent-first or multi-agent. The peer median for your size band shows 31 percent. Assume, for the example, that 260 users sit in the denominator.</p><p>Your cohort split looks like this:</p><ul><li>Core product engineers: 180 users, 61 agentic, about 34 percent.</li><li>Contract reviewers who mainly use code review: 50 users, 2 agentic, about 4 percent.</li><li>New hires with seats assigned in the last ten days: 30 users, 1 agentic, about 3 percent.</li></ul><p>Together that is 64 of 260, roughly 25 percent. The headline gap to the peer median is six points. The core engineering cohort sits three points above the median.</p><p>The tempting slide now reads, “Our engineers beat the industry.” That claim fails the worksheet. You do not know the peer cohort mix. Their median may include reviewers and new hires as well. Removing your low cohorts while keeping theirs is not normalization. It is picking the comparison you like.</p><p>The defensible statement is narrower: “Our overall score is below the peer median. The gap sits mainly in two cohorts whose role or tenure makes agent-first use unlikely this month. Our core engineering cohort is close to the peer median.”</p><p>The merge-rate comparison needs the same care. In this example, 196 users are nonagentic: 119 core engineers, 48 reviewers, and 29 new hires. That means 77 of the 196, about 39 percent, are reviewers or new hires. The agentic group is almost all core engineers (61 of 64). So the merge-rate gap partly compares roles and tenure, not only agent use. Write that next to the merge-rate figure. If your own pull request data allows it, compare the 61 agentic and 119 nonagentic core engineers as an internal check, and label it as yours, not the dashboard’s.</p><p>Client mix adds one more line. Suppose totals_by_client shows the data team under opencode and a large product_selected share from code_review. Note both facts. Do not claim either one moves the benchmark, because the source does not say so.</p><h3>Decide What the Slide Is Allowed to Say</h3><p>Operator judgment: let the comparability call from the worksheet limit the claim.</p><ul><li><strong>Comparable:</strong> the peer group is the one you selected, the denominator is confirmed, and your cohorts are not unusual for your industry. Report the gap directly.</li><li><strong>Comparable with caveats:</strong> the peer group and denominator are confirmed, but your cohort mix has a known skew. Show the headline gap and the cohort note together on one slide.</li><li><strong>Not comparable yet:</strong> the peer group widened, only the median is shown, or the denominator is unconfirmed. Report your own trend across several windows and leave the peer line off.</li></ul><p>GitHub frames the comparison as peer context for setting realistic goals, finding adoption gaps, and communicating progress. Operator judgment: set any goal per cohort, not on the blended number, so an onboarding wave does not read as a failure.</p><h3>Where Cohort Notes Stop Protecting Your Claim</h3><ul><li>The worksheet describes your composition, not the peers’. It narrows bad claims. It cannot produce a true like-for-like comparison.</li><li>The changelog does not define how users are classified as agent-first or multi-agent, or which seats enter the denominator. Check the dashboard documentation before relying on either.</li><li>The benchmark is dashboard-only, so cohort math is manual and easy to get wrong. Keep the arithmetic visible in the slide notes.</li><li>Client and customization signals carry stated accuracy limits: best-effort client grouping, requests that are not prompts, and telemetry that can undercount.</li><li>Early peer groups may be small or widened. A ranking from a thin peer group deserves less weight than your own trend.</li><li>Nothing here measures whether agentic work produced better software. Merge rate is one outcome signal, not a quality verdict.</li></ul><h3>Capture Three Lines Under the Next Screenshot</h3><p>Open the Copilot impact dashboard and capture the industry comparison once. Under it, write three lines: the peer group label the dashboard shows, the window end date, and how many of your seats were assigned inside that window. If you cannot fill the third line, that is the first gap to close before anyone presents the benchmark.</p><h3>Sources</h3><ul><li><a href="https://github.blog/changelog/2026-10-22-industry-comparisons-in-the-copilot-impact-dashboard/">Industry comparisons in the Copilot impact dashboard</a> (GitHub Changelog, October 22, 2026)</li><li><a href="https://github.blog/changelog/2026-10-23-usage-metrics-api-adds-usage-from-tools-like-opencode/">Usage metrics API adds usage from tools like OpenCode</a> (GitHub Changelog, October 23, 2026)</li><li><a href="https://github.blog/changelog/2026-10-22-custom-skills-agents-and-mcp-servers-in-usage-metrics-api/">Custom skills, agents, and MCP servers in usage metrics API</a> (GitHub Changelog, October 22, 2026)</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=06bee52aab00" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lock Copilot Feature Defaults Before Inheritance Changes the Fleet]]></title>
            <link>https://medium.com/@thereviewsurface/lock-copilot-feature-defaults-before-inheritance-changes-the-fleet-529925769678?source=rss-66b7ba83b889------2</link>
            <guid isPermaLink="false">https://medium.com/p/529925769678</guid>
            <category><![CDATA[enterprise-software]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-governance]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[The Review Surface]]></dc:creator>
            <pubDate>Fri, 06 Nov 2026 13:01:02 GMT</pubDate>
            <atom:updated>2026-11-06T13:01:02.052Z</atom:updated>
            <content:encoded><![CDATA[<h4>Trace global defaults, delegated model policies, and managed-setting refresh so every inherited Copilot value becomes a choice.</h4><figure><img alt="Hand-drawn tree of blank setting cards filled by an amber wash flowing from a top card, with one card under the middle pipe branch held by a teal padlock and check mark, and a laptop with a padlock and refresh arrow at the end of a dotted line." src="https://cdn-images-1.medium.com/max/1024/1*0ZxtO51CwvDN_PYrcdVbaw.png" /><figcaption>Values flow down from one default into every blank setting, except the card an operator has already locked by choice.</figcaption></figure><p><em>This article was produced with AI assistance and reviewed before publication.</em></p><p>A platform owner runs a quarterly policy check on a Copilot Enterprise account with three organizations. One setting on the “MCP servers in Copilot” page reads Enabled in the payments organization. Nobody on that team remembers choosing it. The value came from the global default policy, which an admin set to Enabled after GitHub announced it in September and never revisited.</p><p>Nothing broke. But a feature reached a sensitive organization because a blank setting inherited a value, not because a person decided.</p><p>The rollout that filled those blanks already ran, ending October 26. This audit cannot undo it. Its job is the next change: lock the values you care about before the next eligible feature or default change propagates through the fleet. It covers three inheritance paths: the global default for new features, delegated model policies, and managed settings on developer machines.</p><h3>Three Paths a Setting Can Travel</h3><p>GitHub’s <a href="https://github.blog/changelog/2026-10-22-global-default-for-copilot-features-generally-available/">global default changelog</a> describes the first path. On Copilot Business and Copilot Enterprise plans, a global default policy covers generally available features and supported client capabilities. Eligible features left Unconfigured are set to the selected default: Enabled, Disabled, or Let organizations decide.</p><p>The second path is model control. The <a href="https://github.blog/changelog/2026-10-19-copilot-model-policy-api-for-enterprise-orgs-and-teams/">model policy API changelog</a> says enterprise policies can delegate model control to organizations in organization mode, or to teams and apps in enterprise teams mode.</p><p>The third path runs to the client. The <a href="https://github.blog/changelog/2026-10-13-enterprise-managed-settings-enforcement-updates/">managed settings changelog</a> explains how a policy change reaches Copilot CLI, VS Code, and the GitHub Copilot app, and what happens when a client cannot confirm current policy.</p><h3>Rules You Can Rely On Today</h3><p><strong>The global default page sets timing and scope.</strong> Enforcement rolled out gradually through October 26, so it took effect at different times for different enterprises and organizations. It applies to eligible settings on “Features &amp; clients” and “MCP servers in Copilot”. You can review the value under AI Controls &gt; Copilot &gt; Default policy for new features.</p><p>It also states three rules. The fill of Unconfigured settings is a one-time change, and later changes to the default policy do not change feature policies that are already set. Explicit choices are preserved. Preview features stay opt-in, and a preview you opted into keeps that choice when it becomes generally available. Otherwise, the default applies once the feature becomes eligible. That last rule is why the audit matters now: every future eligible feature still arrives through the default.</p><p><strong>The model policy page makes policy readable in code.</strong> GET and PATCH endpoints are generally available at enterprise, enterprise team, agent app, and organization levels, and the <a href="https://github.blog/changelog/2026-10-19-copilot-model-policy-api-for-enterprise-orgs-and-teams/">changelog</a> lists the paths.</p><p><strong>The managed settings page controls how fresh client policy is.</strong> Setting forceRemoteSettingsRefresh to true makes supported clients fetch current server-managed settings at startup instead of trusting a cache. It can be delivered as a server-managed, MDM-managed, or file-based setting. If the client cannot confirm current policy, it fails closed. Without the setting, clients keep the normal cache for faster startup and resilience during transient service failures.</p><p>The same page adds a minimum client version to the sandbox key. When that key is in managed settings, users pinned to older Copilot clients must update to keep using Copilot. GitHub says more governance keys will get version requirements over time.</p><p>The pages do not say which features are eligible, which exceptions apply, at which level the default fills a value, or what the API responses look like. Confirm those in GitHub Docs before acting.</p><h3>The Inheritance Lock Record</h3><p>Fill in one record per setting you care about.</p><ul><li><strong>Setting:</strong> the feature name and its page, either “Features &amp; clients” or “MCP servers in Copilot”.</li><li><strong>Level:</strong> enterprise or the specific organization.</li><li><strong>Value source:</strong> explicit choice, or filled from the global default.</li><li><strong>Global default today:</strong> Enabled, Disabled, or Let organizations decide.</li><li><strong>Preview status:</strong> not a preview, preview opted in, or preview not opted in.</li><li><strong>Model control owner:</strong> enterprise, organization (organization mode), or team or app (enterprise teams mode).</li><li><strong>Model policy snapshot:</strong> endpoint called, date, and where the saved response lives.</li><li><strong>Client delivery:</strong> server-managed, MDM-managed, or file-based, and whether forceRemoteSettingsRefresh is on.</li><li><strong>Version gate:</strong> whether the sandbox key is present and which clients it will force to update.</li><li><strong>Decision:</strong> lock explicit, accept inherited, or delegate, with an owner and a review date.</li></ul><p>The “Value source” line matters most. The changelog does not say the settings page marks which values were filled by the rollout, so take it from the audit log or your change records, not from the page.</p><h3>Walk the Payments Setting</h3><p>Return to the opening scene, which is an illustrative example rather than a reported incident. The global default is Enabled. Nobody set the MCP item explicitly, so the rollout filled it.</p><p>The record reads: Setting, an eligible MCP item on “MCP servers in Copilot”. Level, to be confirmed. Value source, filled from the global default. Decision, pending.</p><p>Changing the default to Disabled now would not fix this. The changelog says later default changes do not touch settings that are already set.</p><p>What follows is operator judgment, not GitHub guidance. First, find which level holds the filled value. The source does not say. If the enterprise holds Enabled, the payments organization owner likely cannot override it. An enterprise owner must make an explicit enterprise choice, either Disabled or Let organizations decide, before payments can choose. Confirm that precedence in GitHub’s docs. Once a person sets the value, the record moves to “explicit choice”, and the payments security lead signs it.</p><p>Next, the model line. The enterprise runs in organization mode, so payments controls its own models. The owner calls the organization endpoint for payments and saves the response with the date. If a later PATCH changes it, the diff is reviewable.</p><p>Last, the client line. Payments developers use VS Code and Copilot CLI. If the MDM can target the payments machines, the owner delivers forceRemoteSettingsRefresh there as an MDM-managed setting, so a tightened policy takes effect before Copilot starts. The record names who answers when a laptop fails closed during an outage.</p><p>Finally, the owner switches the default to “Let organizations decide”. The next eligible feature then arrives as a decision for each organization instead of a silent Enabled.</p><h3>Source Claims Versus Operator Judgment</h3><p>The changelogs support the mechanics: the fill rule, the preserved choices, the four policy levels, the delegation modes, the refresh flag, and the sandbox version gate.</p><p>The following points are operator judgment, not GitHub guidance:</p><ul><li>Treat every value filled by the rollout as unreviewed until someone signs it.</li><li>Locate the level holding a filled value before deciding who can change it.</li><li>Prefer “Let organizations decide” when organizations carry different risk.</li><li>Snapshot model policies before any PATCH, so changes can be compared.</li><li>Turn on forced refresh only where a stale policy costs more than a blocked start.</li><li>Plan for the sandbox version gate before adding the key, not after users are locked out.</li></ul><h3>What the Record Cannot Show</h3><p>This record does not list eligible features or exceptions. GitHub keeps that in its default availability documentation.</p><p>It does not describe API response fields, since the changelog does not show them. Read the REST reference before you automate anything.</p><p>Forced refresh covers Copilot CLI, VS Code, and the GitHub Copilot app. A server-managed value also needs one successful delivery before it starts requiring refreshes, while MDM and file-based delivery can require freshness before first sign-in.</p><h3>Lock One Value Before the Next Feature Lands</h3><p>Before your next policy review, open AI Controls &gt; Copilot &gt; Default policy for new features and write down the current value. Then pick one sensitive organization and one setting on “MCP servers in Copilot”. Use the audit log or change records to establish whether its value was chosen or inherited, and at which level.</p><p>That single “Value source” line is your first lock record. Add the next one before the next eligible feature arrives.</p><h3>Sources</h3><ul><li><a href="https://github.blog/changelog/2026-10-22-global-default-for-copilot-features-generally-available/">Global default for Copilot features generally available</a></li><li><a href="https://github.blog/changelog/2026-10-19-copilot-model-policy-api-for-enterprise-orgs-and-teams/">Copilot model policy API for enterprise, orgs, and teams</a></li><li><a href="https://github.blog/changelog/2026-10-13-enterprise-managed-settings-enforcement-updates/">Enterprise managed settings enforcement updates</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=529925769678" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build a Customization Adoption Ledger Before You Expand the Rollout]]></title>
            <link>https://medium.com/@thereviewsurface/build-a-customization-adoption-ledger-before-you-expand-the-rollout-b198f5fa27fd?source=rss-66b7ba83b889------2</link>
            <guid isPermaLink="false">https://medium.com/p/b198f5fa27fd</guid>
            <category><![CDATA[engineering-metrics]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-governance]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[developer-experience]]></category>
            <dc:creator><![CDATA[The Review Surface]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 13:01:02 GMT</pubDate>
            <atom:updated>2026-11-04T13:01:02.143Z</atom:updated>
            <content:encoded><![CDATA[<h4>A four-signal ledger for comparing named Copilot customization activity, client coverage, version health, and real task outcomes.</h4><figure><img alt="Hand-drawn adoption ledger receiving five customization symbols, checking coverage, evidence, and version health, then branching to expand, hold, or investigate." src="https://cdn-images-1.medium.com/max/1024/1*ya4jEutF6WqsaoDloJe5xA.png" /><figcaption>Five customization types enter a ledger, pass coverage and evidence checks, then split into expand, hold, and investigate decisions.</figcaption></figure><p><em>This article was produced with AI assistance and reviewed before publication.</em></p><p>Your dashboard says a custom agent was used 240 times last month. The number looks strong enough to justify a wider rollout. Then you learn that one team’s customizations still appear under other, two IDE groups are on versions that miss agent activity, and one prompt can produce several model requests. The adoption story is no longer one number.</p><p>This is a ledger for deciding whether to expand a Copilot customization, not a complete guide to the usage metrics API. It helps you connect named customization activity, client coverage, version health, and a review decision without pretending that telemetry is exact accounting.</p><p>The working rule is simple: no customization earns a broader rollout from a count alone. It needs a named entry, a known coverage boundary, a stable comparison window, and evidence that the workflow improved.</p><h3>Start With What the New Fields Can Prove</h3><p>GitHub’s <a href="https://github.blog/changelog/2026-10-22-custom-skills-agents-and-mcp-servers-in-usage-metrics-api/">customization metrics update</a> adds configured names to five arrays: skills, custom agents, MCP servers, slash commands, and plugins. Enterprise and organization reports can now show up to 25 named entries in each list before remaining activity is grouped under other.</p><p>That change makes a practical adoption ledger possible. You can track a specific internal skill or MCP server instead of treating every custom item as one bucket. The existing interaction and distinct-use calculations did not change, so the names improve attribution rather than redefine the counts.</p><p>The same source sets the first limit. Names come from supported clients and minimum versions. IDE integrations that are not built on the Copilot SDK do not report customization names. Outdated clients or blocked telemetry can undercount activity. Historical report days are not rewritten with the new names.</p><p>The API can show that a named item appeared in covered telemetry. It cannot prove that every eligible developer used it, that the item caused a better outcome, or that missing activity means rejection.</p><h3>Separate Customization Adoption From Client Usage</h3><p>GitHub’s <a href="https://github.blog/changelog/2026-10-23-usage-metrics-api-adds-usage-from-tools-like-opencode/">client metrics update</a> adds totals_by_client. It reports successful model requests, sessions, token use, and model breakdowns for clients such as Copilot CLI, the GitHub app, VS Code, JetBrains, Codex, Claude Code, and OpenCode.</p><p>This is a different measurement plane. Customization arrays answer which named skill, agent, server, command, or plugin appeared. Client totals answer where model traffic came from. Keep both in the ledger, but do not merge them into one adoption rate.</p><p>A request count is not a prompt count. One prompt can trigger several model calls. Client identity is also a best-effort grouping based on the integration identifier sent with a request. Use client totals to find shifts and coverage gaps, not to rank people or claim exact task volume.</p><p>If named use grows while client sessions stay flat, investigate before celebrating. If sessions grow but the skill remains under other, check versions and naming before calling adoption stalled.</p><h3>Build One Ledger Row Per Customization</h3><p>Use one row for each item you may expand. A spreadsheet, issue template, or small database table is enough. Keep these fields visible to the reviewer.</p><ul><li><strong>Customization identity:</strong> configured name, type, owner, version, and rollout group.</li><li><strong>Report window:</strong> exact 1-day or 28-day period and the date the report was processed.</li><li><strong>Named activity:</strong> interaction count and distinct-use count, plus whether activity overflowed into other.</li><li><strong>Client context:</strong> relevant request count, session count, token use, and model selection mode.</li><li><strong>Coverage check:</strong> client family, minimum supported version, telemetry status, and unsupported paths.</li><li><strong>Outcome evidence:</strong> one task measure such as review corrections, successful completions, rollback rate, or time to an accepted result.</li><li><strong>Decision:</strong> expand, hold, investigate, or retire, with an owner and next review date.</li></ul><p>The row is the concrete artifact. It forces the usage signal and its limits to travel with the decision.</p><h3>Walk an MCP Server Example Through the Ledger</h3><p>Assume a platform team releases an internal MCP server that exposes deployment runbooks. The first group has 20 developers using Copilot CLI and two SDK-based IDE clients.</p><p>The 28-day report shows the configured server name in totals_by_mcp, with 68 interactions from 11 distinct users. Client totals show 120 Copilot CLI sessions and 90 VS Code sessions. Those numbers prove that the server appeared in covered activity and that both clients sent model traffic. They do not prove that 11 people completed a runbook task successfully.</p><p>The owner samples ten deployment tasks. Eight used the intended runbook, one stopped because the server returned stale content, and one used a manual path. Reviewers corrected two unsafe command suggestions before execution. That outcome evidence belongs beside the telemetry.</p><p>The coverage check then finds that one IDE group is below the required SDK version for named customization reporting. Their missing server name cannot be treated as non-adoption. The decision becomes hold, not expand: fix the stale runbook, update the affected clients, and repeat the same ten-task sample.</p><h3>Add a Version-Health Gate</h3><p>The <a href="https://github.blog/changelog/2026-10-06-update-your-ide-to-restore-agent-activity-in-copilot-usage-metrics/">IDE attribution notice</a> documents a concrete failure mode. Some IDE versions moved agent sessions to the Copilot SDK without identifying the originating IDE. Activity was omitted from reports or attributed to Copilot CLI, and the missing history cannot be backfilled.</p><p>GitHub says detailed client-side metrics can also be incomplete when telemetry is disabled, a proxy blocks the endpoint, an extension is outdated, or a client does not send the required events. Per-user reports expose last-known IDE and plugin versions that can help find outdated clients.</p><p>Put a version gate before every adoption decision:</p><ul><li>What share of the rollout group is on a version that reports the metric you are using?</li><li>Did the client or SDK requirement change during the comparison window?</li><li>Is telemetry allowed through the network path?</li><li>Does the report contain a sudden CLI increase that could be attribution drift?</li><li>Can the missing period be recovered, or must the ledger mark it as a permanent gap?</li></ul><p>If version health is unknown, do not calculate a precise adoption percentage. Record the named counts, describe the uncovered group, and keep the decision provisional.</p><h3>Use Four Decision States</h3><p>A binary adopted-or-not label hides too much. Use four states instead.</p><p><strong>Expand</strong> when the named item appears across the intended covered clients, version health is acceptable, and sampled tasks show a useful outcome without a new safety or review burden.</p><p><strong>Hold</strong> when the signal is promising but the window is short, the task sample is small, or one fix is already identified. A hold needs a dated next check.</p><p><strong>Investigate</strong> when named activity and client activity disagree, other grows, versions are mixed, or the outcome sample contradicts the usage trend.</p><p><strong>Retire</strong> when the item has reliable coverage but repeated low use, no clear task benefit, or a safer supported path replaces it.</p><p>These states keep uncertainty visible. They also stop a dashboard spike from becoming a permanent platform commitment.</p><h3>Review the Ledger Before Sharing It</h3><p>Configured names are trimmed, limited to 128 characters, and may reveal internal projects or workflows. GitHub recommends reviewing names before sharing reports outside the organization. Treat the ledger the same way.</p><p>Remove personal rankings. Check whether names expose customers, incidents, repository paths, or security-sensitive functions. Share the smallest useful aggregation and keep raw per-user data with the people authorized to view Copilot metrics.</p><h3>Run a Two-Window Trial</h3><p>Start with one customization and one rollout group. Capture a 28-day baseline before expansion. Then run the same ledger for the next 28-day window after the team fixes version gaps and communicates the intended workflow.</p><p>Keep the outcome sample small and repeatable. Five to ten real tasks can reveal whether the customization saves review work, improves evidence, or creates new failure modes. Do not change the item, client mix, and scoring rule at the same time.</p><p>At the review, compare four things: named activity, client sessions, coverage health, and task outcomes. Expand only when they tell a compatible story. If they disagree, the ledger has done its job. It has turned a vague adoption claim into a specific investigation.</p><h3>Sources</h3><ul><li><a href="https://github.blog/changelog/2026-10-22-custom-skills-agents-and-mcp-servers-in-usage-metrics-api/">Custom skills, agents, and MCP servers in usage metrics API</a></li><li><a href="https://github.blog/changelog/2026-10-23-usage-metrics-api-adds-usage-from-tools-like-opencode/">Usage metrics API adds usage from tools like OpenCode</a></li><li><a href="https://github.blog/changelog/2026-10-06-update-your-ide-to-restore-agent-activity-in-copilot-usage-metrics/">Update your IDE to restore agent activity in Copilot usage metrics</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b198f5fa27fd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Define a Notification-to-Code Boundary Before Copilot Opens the Task]]></title>
            <link>https://medium.com/@thereviewsurface/define-a-notification-to-code-boundary-before-copilot-opens-the-task-f34e8542c365?source=rss-66b7ba83b889------2</link>
            <guid isPermaLink="false">https://medium.com/p/f34e8542c365</guid>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[ai-coding]]></category>
            <category><![CDATA[microsoft-teams]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[github-copilot]]></category>
            <dc:creator><![CDATA[The Review Surface]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 13:01:03 GMT</pubDate>
            <atom:updated>2026-11-02T13:01:03.039Z</atom:updated>
            <content:encoded><![CDATA[<h4>A five-gate record for deciding when a Teams issue notification may become a Copilot investigation, code change, or pull request.</h4><figure><img alt="Hand-drawn workflow where a Teams notification passes an approval gate before repository changes and a pull request, while rejected paths go to investigation." src="https://cdn-images-1.medium.com/max/1024/1*pRaIPwOZ3e-c01AnWU7wng.png" /><figcaption>A notification crosses a human approval gate before repository work and pull-request creation.</figcaption></figure><p><em>This article was produced with AI assistance and reviewed before publication.</em></p><p>A bug report lands in a Microsoft Teams channel. The message names the broken page, links an issue, and tags the GitHub app. One mention can now ask GitHub Copilot to investigate the issue, change code, and open a pull request. The useful shortcut is also the risk: a notification written to inform people can become an instruction to act on a repository.</p><p>This is a boundary design for that handoff, not a setup guide for Teams or a claim that chat should replace issue triage. It helps you decide which notifications may start an investigation, which may authorize a code task, and which must stop for human review.</p><p>The boundary is simple: a notification can propose work, but it should not define its own authority. Repository scope, task clarity, test evidence, and review ownership must come from a separate decision record.</p><h3>What GitHub’s Updates Actually Enable</h3><p>GitHub’s October 23 announcement describes a direct path from a Teams issue notification to an @GitHub request that investigates the issue, fixes the bug, and creates a pull request. It also keeps the final review, test, and merge with the team. That separation matters. The feature shortens the path to a candidate change; it does not remove the need to judge that change.</p><p>The <a href="https://github.blog/changelog/2026-10-15-copilot-in-slack-and-teams-adds-model-and-repository-updates/">earlier Slack and Teams update</a> expands the possible scope. A conversation can work across multiple repositories, create issues, and open pull requests. In Slack, @GitHub can also use shared messages and threads as context. The update reports better recovery from interruptions across Slack and Teams. This can reduce copying, but it makes an ambiguous repository boundary more costly.</p><p>The <a href="https://github.blog/changelog/2026-10-23-turn-notifications-into-code-with-github-copilot-in-teams/">notification-to-code announcement</a> proves the interaction exists and names the intended review step. It does not document how your team should classify notifications, choose repositories, or decide when chat context is sufficient.</p><p>That missing policy is the reader’s job.</p><h3>Keep Four Permissions Separate</h3><p>A single @GitHub mention can hide four different permissions. Treat them as separate choices.</p><ul><li><strong>Read context:</strong> inspect the issue, linked discussion, and selected repositories.</li><li><strong>Investigate:</strong> trace a likely cause and report evidence without changing code.</li><li><strong>Change code:</strong> create a branch or working change inside named repositories.</li><li><strong>Open a pull request:</strong> publish the candidate change for team review.</li></ul><p>Do not bundle these into one yes-or-no switch. A vague alert may be safe for read-only investigation but too weak for a code change. A clear bug with a named repository may allow a patch but still require a human to decide whether a pull request should be opened.</p><p>This staged model gives reviewers a smaller question at each gate. It also leaves a clearer record when the task stops.</p><h3>Use a Five-Gate Boundary Record</h3><p>Before a Teams notification becomes a coding task, write one compact record. It can be a form, an issue template, or a bot-generated card that a person confirms.</p><p><strong>Gate 1: Trigger quality</strong></p><ul><li>What observable failure started the task?</li><li>Is there an issue or reproducible report, not just a reaction in chat?</li><li>Does the message include expected and actual behavior?</li></ul><p><strong>Gate 2: Repository scope</strong></p><ul><li>Which repository may be read?</li><li>Which repository may be changed?</li><li>Is cross-repository investigation allowed, and is cross-repository editing allowed separately?</li></ul><p><strong>Gate 3: Change ceiling</strong></p><ul><li>Is the task investigation only, patch allowed, or pull request allowed?</li><li>Which files, services, secrets, generated assets, or deployment settings are out of scope?</li></ul><p><strong>Gate 4: Evidence requirement</strong></p><ul><li>What reproduction must pass before work starts?</li><li>Which tests must pass before a pull request can be opened?</li><li>What logs, screenshots, or command output must accompany the result?</li></ul><p><strong>Gate 5: Review owner</strong></p><ul><li>Who checks that the patch matches the issue?</li><li>Who reviews security, data, or deployment effects?</li><li>Who may merge?</li></ul><p>The record is the concrete artifact for this workflow. It turns a conversational request into a bounded engineering task without pretending that a chat thread is a full specification.</p><h3>Walk One Notification Through the Gates</h3><p>Consider this example: a Teams notification says the checkout page returns an error after a shipping address is edited. The thread links an issue, but someone replies, “@GitHub fix this in frontend and open a PR.”</p><p>Gate 1 passes only if the issue gives a reproducible sequence and expected result. If it does not, the allowed action is investigation and a question back to the team.</p><p>Gate 2 names storefront-web as the editable repository. The agent may read shipping-api to trace the response contract, but it may not change that repository. This distinction matters because GitHub&#39;s multi-repository support can keep both repositories in one conversation.</p><p>Gate 3 permits a code change in the checkout form and its tests. It excludes payment code, deployment settings, and dependency upgrades. A nearby cleanup may be useful, but it belongs in another task.</p><p>Gate 4 requires the failing case to reproduce before the patch, then pass after it. Existing checkout tests must pass. The pull request must include the failing input and the test result.</p><p>Gate 5 assigns a storefront maintainer to review and keeps merge permission outside the chat workflow.</p><p>The notification now starts a bounded task. Without that record, the same sentence could authorize an investigation, a two-repository refactor, or a public pull request depending on how the agent interprets the thread.</p><h3>Decide What May Run Automatically</h3><p>Automation should expand only when the inputs and evidence become more reliable. A useful default is:</p><ul><li><strong>Auto-start investigation</strong> when the notification links a tracked issue, names the affected product area, and contains a reproducible symptom.</li><li><strong>Require human approval before code changes</strong> when repository scope is inferred, multiple repositories are involved, or the issue touches permissions, billing, authentication, or customer data.</li><li><strong>Allow pull-request creation</strong> only when the change ceiling, required tests, and review owner are explicit.</li><li><strong>Never infer merge authority</strong> from permission to investigate, edit, or open a pull request.</li></ul><p>These are operator rules, not claims from GitHub’s announcements. The official posts show what the app can do. Your boundary record decides what it may do in your environment.</p><h3>Treat Chat Context as Evidence, Not Policy</h3><p>The October 15 update says @GitHub can use shared Slack messages and threads as context. Context can explain a symptom, reveal a recent decision, or name the right owner. It can also contain speculation, old assumptions, and instructions written for a different repository.</p><p>Save the relevant message links in the task record, but convert their meaning into explicit fields. “We discussed this last week” is not a scope rule. “Read shipping-api; edit only storefront-web&quot; is.</p><p>The same principle applies to interruption recovery. Better recovery can make a task resume more smoothly, but it does not prove that the resumed task still has fresh context. Recheck the issue state, branch state, and approval before continuing a code-changing step.</p><h3>Put Governance on the Correct Plane</h3><p>GitHub’s <a href="https://github.blog/changelog/2026-10-13-enterprise-managed-settings-enforcement-updates/">enterprise managed settings update</a> describes clients retrieving current policy at startup and failing closed when required policy freshness cannot be confirmed. It also introduces minimum client-version enforcement for the sandbox setting.</p><p>That source supports a broader control lesson: important policy should be current before an agent starts. It does not say that forceRemoteSettingsRefresh governs every action of the GitHub app in Teams. Do not stretch a client-management feature into a claim about chat authorization.</p><p>Use enterprise controls for the settings they actually cover. Use the boundary record for task-level authority. The two layers can support each other, but they are not interchangeable.</p><h3>Stop on These Boundary Failures</h3><p>Reject or pause the task when any of these conditions appears:</p><ul><li>The notification names no repository and the likely target is ambiguous.</li><li>The thread asks for a fix but supplies no reproducible symptom.</li><li>A cross-repository investigation silently turns into cross-repository editing.</li><li>The requested change touches secrets, permissions, billing, authentication, or production data without a named reviewer.</li><li>The agent cannot show the failing case or the required test result.</li><li>The issue changed, closed, or gained new constraints while the task was interrupted.</li><li>The person requesting the change is also the only reviewer for a high-impact patch.</li></ul><p>Stopping is a valid result. The task record should say which gate failed and what evidence would let the work continue.</p><h3>Review the Pull Request Against the Boundary</h3><p>When a pull request is opened, compare it with the record rather than reviewing only the diff.</p><ul><li>Did the agent edit only the allowed repositories and files?</li><li>Does the pull request link the triggering issue and relevant Teams context?</li><li>Is the reproduced failure visible?</li><li>Did every required test pass?</li><li>Did the patch stay below the change ceiling?</li><li>Is the named reviewer still the right owner?</li></ul><p>This review catches a class of error that code quality checks miss: a technically sound patch that was never authorized at that scope.</p><h3>Start With One Investigation-Only Trial</h3><p>Pick one low-risk notification that already links a clear issue. Allow @GitHub to investigate, but do not allow code changes on the first run. Fill in the five-gate record and compare the agent&#39;s findings with the issue and repository evidence.</p><p>If the repository choice, suspected cause, and required test are all correct, repeat the trial with a tightly bounded patch. Keep <a href="https://medium.com/@thereviewsurface/how-to-design-human-approval-gates-that-people-will-use-6ea50c09f86c">pull-request creation as a separate approval</a> until the record is reliable enough that reviewers can spot scope drift quickly.</p><p>The goal is not to turn every notification into code. It is to make the few notifications that deserve action cross a visible, reviewable boundary.</p><h3>Sources</h3><ul><li><a href="https://github.blog/changelog/2026-10-23-turn-notifications-into-code-with-github-copilot-in-teams/">Turn notifications into code with GitHub Copilot in Teams</a></li><li><a href="https://github.blog/changelog/2026-10-15-copilot-in-slack-and-teams-adds-model-and-repository-updates/">Multi-repository support and other improvements for GitHub in Slack and Teams</a></li><li><a href="https://github.blog/changelog/2026-10-13-enterprise-managed-settings-enforcement-updates/">Enterprise managed settings enforcement updates</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f34e8542c365" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Run a Task Baseline Before You Switch Copilot to GPT-6.1 Terra]]></title>
            <link>https://medium.com/@thereviewsurface/run-a-task-baseline-before-you-switch-copilot-to-gpt-6-1-terra-f8c9e8d4816a?source=rss-66b7ba83b889------2</link>
            <guid isPermaLink="false">https://medium.com/p/f8c9e8d4816a</guid>
            <category><![CDATA[ai-coding]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[model-evaluation]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[github-copilot]]></category>
            <dc:creator><![CDATA[The Review Surface]]></dc:creator>
            <pubDate>Wed, 28 Oct 2026 13:01:03 GMT</pubDate>
            <atom:updated>2026-10-28T13:01:03.396Z</atom:updated>
            <content:encoded><![CDATA[<h4>A one-task comparison for judging Terra on correctness, review effort, policy access, cost, and a recoverable fallback.</h4><figure><img alt="Hand-drawn workflow showing a coding task passing three baseline checks, splitting between two model paths, and reaching an approval gate with a rollback loop." src="https://cdn-images-1.medium.com/max/1024/1*h8YLtB-iVIY8E0pi2_hy3g.png" /><figcaption>A task baseline compares correctness, review effort, and cost before a model change passes an approval gate.</figcaption></figure><p><em>This article was produced with AI assistance and reviewed before publication.</em></p><p>The model picker changes, the release note says the new option costs less, and the obvious next step seems to be switching. That is exactly when a baseline matters. Without one, a faster or cheaper run can hide a worse edit, more review work, or a task that no longer finishes cleanly.</p><p>This is a one-task comparison method, not a general model ranking. It helps you decide whether GPT-6.1 Terra fits one repeatable coding task in your Copilot workflow. It does not claim that one model is best across languages, repositories, or agent surfaces.</p><p>GitHub says <a href="https://github.blog/changelog/2026-10-26-gpt-6-1-terra-in-github-copilot/">GPT-6.1 Terra is generally available in Copilot</a>, is designed for everyday agentic coding and terminal work, and is billed at provider list pricing under usage-based billing. That is enough reason to test it. It is not proof that it improves your task.</p><h3>Pick One Task That Exposes Review Cost</h3><p>Use a task you already understand well enough to judge. A narrow repository change works better than an open-ended build because you can define the expected files, checks, and stop conditions before the run.</p><p>For example, ask both models to add one validation rule to an existing command-line tool. Lock the prompt, repository revision, allowed files, test command, and time limit. Keep the task small enough to run twice without changing the environment between runs.</p><p>The task should reveal more than whether code was produced. It should show whether the model stayed inside scope, used the existing conventions, passed the same tests, and left a patch that was easy to review.</p><h3>Write the Baseline Card Before the First Run</h3><p>Create a small record with the expected outcome and five measures. Do not choose the measures after seeing Terra’s result.</p><ul><li>Correctness: Did the required behavior pass the agreed tests?</li><li>Scope: Did the patch touch only the allowed files and behavior?</li><li>Review effort: How many material correctness, scope, or verification fixes did the reviewer request?</li><li>Completion: Did the run finish without a stuck loop or manual rescue?</li><li>Cost signal: What best-available usage or billing evidence was visible for the run?</li></ul><p>Add the model name, client surface, repository commit, prompt hash, start time, and final decision. This is the concrete artifact to keep with the pull request or experiment log.</p><p>A simple decision rule prevents launch excitement from moving the goalposts: approve the switch only when correctness and scope both pass, review effort does not rise, and the cost signal improves enough to matter for this task.</p><h3>Run the Same Case Through Both Models</h3><p>Start with the model you use today. Save its patch, test output, tool trace, elapsed time, and review notes. Then reset only the task workspace and repeat with Terra under the same constraints.</p><p>Do not repair the Terra run while it is still running unless the baseline run received the same help. Human rescue can be useful in production, but it makes a comparison hard to interpret.</p><p>GitHub describes Terra as working in focused, consolidated steps on well-scoped tasks. Treat that as a vendor claim to test against your trace. Count whether the model needed repeated prompts, wandered into unrelated files, or stopped before verification. Treat elapsed time as diagnostic unless speed is part of the rule you wrote before both runs.</p><h3>Separate Lower Cost From Better Fit</h3><p>The release note positions Terra as a lower-cost option than GPT-6.1 Sol. Lower cost can justify a switch when the task result stays acceptable. It cannot cancel a correctness failure or a large increase in review effort.</p><p>Use three outcomes instead of a single winner:</p><ul><li>Adopt: Terra passes the hard gates and lowers the cost signal or review burden.</li><li>Keep testing: Terra passes, but the difference is too small or the evidence is incomplete.</li><li>Reject for this task: correctness, scope, completion, or review effort gets worse.</li></ul><p>This wording matters. Rejecting Terra for one task is not a verdict on the model. It is a boundary on where your evidence applies.</p><h3>Check Policy and Availability Before You Standardize</h3><p>GitHub says Business and Enterprise administrators can manage Terra through the Copilot model policy, and new models can be enabled by default unless the global default is off or the model is explicitly disabled. The separate <a href="https://github.blog/changelog/2026-10-19-copilot-model-policy-api-for-enterprise-orgs-and-teams/">model policy API release</a> adds GET and PATCH endpoints for enterprise, team, app, and organization policy levels.</p><p>Before you update a shared workflow, record which policy level controls the model and whether the intended users can actually select it. A successful personal test is not a deployment plan if a team policy blocks the model or delegates control elsewhere.</p><p>Also keep the baseline runnable with a supported alternative. GitHub’s <a href="https://github.blog/changelog/2026-10-19-github-copilot-models-deprecated-on-october-19-2026/">October 19 deprecation notice</a> shows why: model availability changes, and administrators may need to enable replacements. A reusable case turns the next forced migration into a measured decision instead of a hurried guess.</p><h3>Read the Result Like an Operator</h3><p>Suppose the current model passes all tests with one reviewer correction. Terra also passes, completes sooner, and shows a lower usage cost, but the reviewer finds three scope changes outside the requested file. The cost result is real, yet the baseline says to hold the switch.</p><p>Now suppose a second prompt revision removes those scope errors. That is a new experiment, not a correction to the old score. Save it as another row and compare the added prompt maintenance with the savings.</p><p>The point is not to produce a scientific benchmark from two runs. The point is to make one operational choice with visible evidence and known limits.</p><h3>Use a Small Approval Gate</h3><p>Before changing the default model for this task, check the record in order:</p><ul><li>Both runs used the same repository state and task contract.</li><li>Correctness and scope passed for Terra.</li><li>Review effort stayed flat or fell.</li><li>The cost or speed difference is large enough to affect the workflow.</li><li>Policy allows the model on every client surface the task uses.</li><li>A supported fallback and the baseline artifacts remain available.</li></ul><p>If any hard gate fails, keep the current default. If the evidence is merely thin, schedule another controlled run instead of turning uncertainty into a broad recommendation.</p><h3>Make the Next Model Change Cheaper</h3><p>Keep the baseline card, prompt, fixture, and review decision together. The next model release can run through the same case. You will still need judgment, but you will not need to reconstruct what “better” meant after the fact.</p><p>One well-chosen task is enough to start. Pick the recurring change that costs you the most review time, run the comparison, and let the saved evidence decide whether Terra earns that lane.</p><h3>Sources</h3><ul><li><a href="https://github.blog/changelog/2026-10-26-gpt-6-1-terra-in-github-copilot/">GPT-6.1 Terra in GitHub Copilot</a></li><li><a href="https://github.blog/changelog/2026-10-19-copilot-model-policy-api-for-enterprise-orgs-and-teams/">Copilot model policy API for enterprise, orgs, and teams</a></li><li><a href="https://github.blog/changelog/2026-10-19-github-copilot-models-deprecated-on-october-19-2026/">GitHub Copilot models deprecated on October 19, 2026</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f8c9e8d4816a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fork a Drive Before Parallel Agents Share a Writable Workspace]]></title>
            <link>https://medium.com/@thereviewsurface/fork-a-drive-before-parallel-agents-share-a-writable-workspace-b8ab5531e22f?source=rss-66b7ba83b889------2</link>
            <guid isPermaLink="false">https://medium.com/p/b8ab5531e22f</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[vercel]]></category>
            <category><![CDATA[coding-agents]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[automation]]></category>
            <dc:creator><![CDATA[The Review Surface]]></dc:creator>
            <pubDate>Mon, 26 Oct 2026 13:01:03 GMT</pubDate>
            <atom:updated>2026-11-01T20:08:18.485Z</atom:updated>
            <content:encoded><![CDATA[<h4>A three-worker collision test and cleanup ledger for keeping parallel agent workspaces isolated without losing evidence of each result.</h4><figure><img alt="A locked base storage box branches into three colored workspace forks, separate sandboxes, and individual cleanup markers, while a red path blocks shared writes." src="https://cdn-images-1.medium.com/max/1024/1*hjB8mMmEEf6Mm4OfH3UAXA.png" /><figcaption>Editorial diagram: one protected base workspace branches into three isolated writable forks, each with its own cleanup path.</figcaption></figure><p><em>This article was produced with AI assistance and reviewed before publication.</em></p><p>Three coding agents start from the same dependency cache and repository checkout. The first updates a lockfile. The second rewrites generated assets. The third deletes a temporary directory that another run still needs. All three jobs finish, but the shared workspace no longer explains which run changed what.</p><p>Vercel Drives can now outlive one Sandbox, and Drive forks can give parallel workers independent writable copies. That makes persistent workspaces more useful. It also moves an old concurrency decision into the storage plan: which files are shared input, which changes belong to one worker, and who cleans up the copies.</p><p>This is a fork-and-cleanup check for parallel agent workspaces, not a complete Vercel Sandbox storage guide. It helps a solo builder decide when a shared Drive should stay read-only, when each worker needs a fork, and what evidence to keep before deleting anything.</p><h3>Start With the Write Boundary</h3><p>Vercel’s <a href="https://vercel.com/changelog/vercel-drives-is-now-generally-available">general availability announcement</a> says a Drive is persistent storage mounted as a directory in a Sandbox. Its files remain after that Sandbox stops, and later runs can mount the same Drive. The announcement also introduces writable forks that inherit the source Drive’s data, region, and maximum size while keeping later changes independent.</p><p>That supports a narrow operating rule: do not let parallel agents discover the write boundary by colliding with each other. Declare it before the jobs start.</p><p>A base Drive can hold inputs that every worker should see: a repository checkout, test fixtures, a model, or a warmed dependency cache. Vercel’s <a href="https://vercel.com/docs/sandbox/concepts/drives">Drive documentation</a> allows only one Sandbox at a time to mount a Drive read-write. Parallel readers use point-in-time, read-only snapshots, and those mounts do not receive later writes. If several workers must write, give each one an isolated writable fork.</p><p>The important distinction is not “persistent” versus “temporary.” It is shared source versus worker-owned mutation.</p><h3>Use Three Workspace Roles</h3><p>Name each mounted path by its role. This prevents one convenient directory from becoming an accidental shared database.</p><ul><li><strong>Base input:</strong> the reviewed starting state. Agents do not write here.</li><li><strong>Worker fork:</strong> one writable copy for one run or one clearly named branch of work.</li><li><strong>Result artifact:</strong> the small output that survives the worker, such as a patch, report, test log, or export.</li></ul><p>The base is the source of comparison. The fork is disposable working state. The result is what another system or reviewer consumes.</p><p>This separation matters because Drive forks do not merge back into the original automatically. Vercel’s <a href="https://vercel.com/blog/introducing-vercel-drives-persistent-storage-for-agents">persistent workspace overview</a> says each fork starts with the source contents and keeps its own changes. That is isolation, not reconciliation. Your workflow still needs to decide how a patch, generated file, or report moves out of the fork.</p><h3>Run a Three-Worker Collision Test</h3><p>Example: before a production workflow depends on Drive forks, run three disposable workers from one reviewed base.</p><p>Give each worker a different mutation:</p><ul><li>Worker A updates one dependency file.</li><li>Worker B creates a generated artifact with the same filename in its own tree.</li><li>Worker C removes a temporary directory in its own tree.</li></ul><p>Then check four outcomes:</p><ul><li>The base Drive still matches its recorded starting digest.</li><li>Each fork contains only its worker’s intended change.</li><li>No worker can see another worker’s later writes.</li><li>Each worker exports a result without treating its entire fork as the deliverable.</li></ul><p>The second check catches hidden setup scripts that write outside the intended directory. The third catches a mount or naming mistake that silently points two jobs at the same writable Drive. The fourth keeps persistence from turning into an excuse to preserve every scratch file.</p><p>Pass only when the base is unchanged and every result can be traced to one worker identifier.</p><h3>Keep a Fork Ledger</h3><p>Use one compact row per worker:</p><ul><li>Base Drive name and starting digest or marker.</li><li>Fork name and worker or run identifier.</li><li>Region and maximum size inherited by the fork.</li><li>Sandbox identifier and mount path.</li><li>Intended writable paths.</li><li>Exported result path and verification state.</li><li>Cleanup owner and earliest safe cleanup time.</li><li>Final state: retained for review, deleted, or cleanup failed.</li></ul><p>This ledger is the article’s concrete artifact. It turns “the agents had separate storage” into evidence a reviewer can check.</p><p>For example, one completed row could read: base deps-v7 at digest a18c, fork run-42-a, Sandbox sb-a, writable path /workspace, exported result patches/run-42-a.diff, result verified, Sandbox stopped and Drive detached, cleanup ready. Use real identifiers from your own run rather than copying these sample values.</p><p>Do not record only the fork names. A name proves that an object existed. It does not prove that the right worker mounted it, that the base stayed unchanged, or that the useful result left the fork before cleanup.</p><h3>Separate Drives From Snapshots</h3><p>Vercel’s <a href="https://vercel.com/docs/vercel-sandbox/concepts/snapshots">snapshot documentation</a> describes snapshots as captures of a Sandbox filesystem and installed packages. They can restore an environment and expire 30 days after last use by default. A Drive has an independent lifecycle and mounts as one directory.</p><p>Use that difference to keep the design clear:</p><ul><li>Choose a snapshot when the environment itself is the thing to restore.</li><li>Choose a Drive when a directory must outlive one Sandbox or move between Sandboxes.</li><li>Use a Drive fork when several workers need the same starting files but independent writable state.</li></ul><p>A snapshot is not a substitute for worker ownership. Restoring the same environment three times can isolate the files, but it does not define which outputs are authoritative or how they should be reconciled.</p><h3>Do Not Treat Forking as a Merge Strategy</h3><p>The weakest workflow ends with three complete directory trees and a human asked to “pick the best one.”</p><p>Ask each worker for a narrow result instead:</p><ul><li>a patch against the base commit;</li><li>a report with source paths and checksums;</li><li>a generated artifact plus the command that produced it;</li><li>or a failure record that says why no result should be applied.</li></ul><p>Validate the result outside the fork before accepting it. For code, <a href="https://medium.com/@thereviewsurface/audit-an-agent-session-before-you-continue-it-locally-c800f1d0f53b">apply the patch to a clean review tree and run the relevant checks</a>. For data, compare schema, row counts, and a content digest. For generated assets, keep the prompt or build command and verify the output independently.</p><p>The fork isolates workers. Review protects the base from a bad result.</p><h3>Make Cleanup a State Transition</h3><p>A cleanup call should follow evidence, not a timer.</p><p>The worker can request cleanup only after its result is exported and verified. The controller can delete the fork only after the Sandbox has stopped or detached it. Vercel blocks deletion while a Drive is attached to a running Sandbox, and deletion permanently removes the stored data. If cleanup fails, keep the ledger row open and surface the retained resource instead of claiming the run is finished.</p><p>Use explicit states:</p><ul><li>working: the Sandbox may still write.</li><li>result_exported: the candidate output exists outside the fork.</li><li>verified: the output passed its checks against the base.</li><li>cleanup_ready: the Sandbox is stopped or the fork is verified as detached.</li><li>deleted or cleanup_failed: the terminal resource state.</li></ul><p>This is operator judgment around the platform primitives. The official sources define persistence, forking, and snapshot behavior. Your workflow must define when a fork is no longer needed and what proof survives it.</p><h3>Make the Next Workspace Decision</h3><p>Use a shared read-only source when workers consume the same data without writing it. Use one writable Drive when only one worker owns the whole mutation path. Use a fork per worker when parallel jobs need independent changes from the same starting state.</p><p>Before your next parallel run, write the three workspace roles, run the collision test, and save the fork ledger. If the base changes, two workers see each other’s writes, or a result cannot be verified after export, stop before scaling the pattern.</p><p>You should check the base digest and exported result before any cleanup begins.</p><p>The goal is not to keep every workspace forever. It is to make parallel work disposable without making its evidence disappear.</p><h3>Sources</h3><ul><li><a href="https://vercel.com/changelog/vercel-drives-is-now-generally-available">Vercel Drives is now generally available</a></li><li><a href="https://vercel.com/blog/introducing-vercel-drives-persistent-storage-for-agents">Introducing Vercel Drives: persistent storage for agents</a></li><li><a href="https://vercel.com/docs/sandbox/concepts/drives">Vercel Sandbox Drives</a></li><li><a href="https://vercel.com/docs/vercel-sandbox/concepts/snapshots">Vercel Sandbox snapshots</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8ab5531e22f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>