<?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 Chamath Silva on Medium]]></title>
        <description><![CDATA[Stories by Chamath Silva on Medium]]></description>
        <link>https://medium.com/@mbckchamathsilva?source=rss-10f03e678c00------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*RWVjSRd-4niSiJs2</url>
            <title>Stories by Chamath Silva on Medium</title>
            <link>https://medium.com/@mbckchamathsilva?source=rss-10f03e678c00------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 20:36:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mbckchamathsilva/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[VS Code Is Retiring Copilot’s Local Harness. Here’s What Changes]]></title>
            <link>https://medium.com/@mbckchamathsilva/vs-code-is-retiring-copilots-local-harness-here-s-what-changes-75b1c373a181?source=rss-10f03e678c00------2</link>
            <guid isPermaLink="false">https://medium.com/p/75b1c373a181</guid>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[visual-studio-code]]></category>
            <dc:creator><![CDATA[Chamath Silva]]></dc:creator>
            <pubDate>Fri, 13 Nov 2026 19:56:29 GMT</pubDate>
            <atom:updated>2026-11-13T19:56:29.898Z</atom:updated>
            <content:encoded><![CDATA[<p><em>You may already be using its replacement without noticing. Here’s what it means for your agents, tools, and automation.</em></p><figure><img alt="Side-by-side illustration comparing the Local harness inside VS Code’s extension host with the Copilot harness in a separate Agent Host. Both can work with local files." src="https://cdn-images-1.medium.com/max/1024/1*o3Wu10omIzoMCqUJsZNK6g.png" /></figure><p>A custom agent loaded in VS Code without a warning. At its approval step, it reported a missing question tool:</p><blockquote><em>“…I can’t collect an approval. I’ll record that and not run the command.”</em></blockquote><p>No question appeared. The turn ended normally, but the approval-requiring command didn&#39;t run.</p><p>The agent file was recognized. Part of the workflow was no longer working.</p><p>VS Code is moving from its <strong>Local harness</strong> to the <strong>Copilot harness</strong>. The <a href="https://code.visualstudio.com/docs/agents/run/move-to-copilot">official migration guide</a> says Local is deprecated and will be removed <strong>by February 2027</strong>. The retirement concerns the older agent implementation. Working with files on your own machine remains supported.</p><p>In my evaluation, new chats already opened on the Copilot harness by default, including in a fresh profile. Your settings, previous choices, and organization policies can affect which harness opens, so <a href="https://code.visualstudio.com/docs/agents/run/agent-harnesses">check your session’s harness</a> rather than assuming it has switched.</p><p>My evaluation covered an existing workflow built around custom agents, delegated tasks, external tools, and human approval steps. Small test agents exercised its tool settings, project instructions, and an approval menu from the workflow.</p><p>The central finding: <strong>an agent loading successfully did not prove that its workflow still behaved as expected.</strong></p><h3>First, what is a harness?</h3><p>When an agent reads a file, edits code, runs a command, and checks the result, a language model is only part of the system.</p><p>The <a href="https://code.visualstudio.com/docs/agents/concepts/agent-harnesses">harness</a> prepares the context sent to the model, makes tools available, coordinates their execution and approvals, and keeps track of the session. The model requests an action; the harness connects that request to the surrounding software.</p><p>For example, “fix this failing test” might involve reading the failure, finding the implementation, editing a file, and running the test again. The harness coordinates that repeated exchange between the model and its tools.</p><p>That explains why changing the harness can matter even when the model stays the same. A capable model still needs the right context and working tools.</p><p>It also helps untangle the naming. <strong>Local is the name of the older harness.</strong> The Copilot harness can also work with local files and commands. Where those commands execute is a separate choice from which harness coordinates them; local execution does not imply that the language model itself runs offline.</p><h3>What changed underneath VS Code?</h3><p>The Local harness runs through VS Code’s extension host. The Copilot harness uses the Copilot SDK in the <a href="https://code.visualstudio.com/docs/agents/concepts/agent-host">Agent Host</a>, separating the agent’s runtime from the editor window.</p><figure><img alt="Architecture diagram comparing the Local harness in VS Code’s Extension Host with the Copilot harness in a separate Agent Host. Both access workspace files and commands; Copilot sessions can continue while the Agent Host runs." src="https://cdn-images-1.medium.com/max/1024/1*A2jVCcpSDHeYvPb_ivrnAg.png" /><figcaption><em>Simplified architecture. The host boxes show agent coordination, not where the language model runs.</em></figcaption></figure><p>The Copilot SDK provides a <a href="https://code.visualstudio.com/docs/agents/run/move-to-copilot#why-move-to-the-copilot-harness">shared runtime across VS Code, Copilot CLI, and the Copilot app</a>. It also supports permission and sandbox controls enforced by the runtime. Those controls still need to be configured for the intended environment.</p><p>A Copilot session can <a href="https://code.visualstudio.com/docs/agents/concepts/agent-host#session-lifetime-and-client-dependencies">continue after its editor window closes</a>, provided the Agent Host and its machine remain running. Editor-provided tools may still need that window to stay connected.</p><p>These changes make compatibility worth checking at the workflow level. A shared runtime can recognize familiar customization files while handling parts of them differently.</p><h3>Where my existing automation needed attention</h3><p>Three findings from that evaluation show why existing automation needs more than a file-format check. The research note at the end records the versions and testing limits.</p><h4>The approval step stalled</h4><p>The agent in the opening example listed vscode/askQuestions, the old question tool. Replacing that entry with ask_user restored the interaction: a choice control appeared, the agent waited for a response, and an Approve selection allowed the workflow to continue. In that run, changing the tool list was enough; the gate instructions stayed unchanged. A menu from my actual workflow also displayed its choices and returned the selected option.</p><p>The missing tool had blocked progress without bypassing the gate. That distinction matters: this run showed a broken approval interaction, not a command executed without permission.</p><p>Seeing an agent in the picker is a discovery check. Watching it ask, wait, and respond correctly to a decision is a behavior check.</p><p>Execution mode mattered as well. In my Autopilot test, the question received an automatic response telling the model the user was unavailable and to choose a pragmatic option. That automatic reply began with User responded:, just like a human answer; the prefix alone did not establish approval. The <a href="https://code.visualstudio.com/docs/agents/run/approvals#how-autopilot-works">current documentation</a> also describes Autopilot as answering blocking questions automatically. For a workflow requiring a person’s decision, use an interactive session and verify that cancellation or an unavailable user leaves the step blocked.</p><p>A custom workflow gate is also separate from the runtime’s permission prompt for a command. Check both when both are part of the process.</p><figure><img alt="Two-column approval flowchart. With vscode/askQuestions, no question appears and the gated command stays blocked. With ask_user, the user can approve, after which separate runtime permission allows the command to run." src="https://cdn-images-1.medium.com/max/1024/1*VhGNaYA4kLD60OQr8czYNw.png" /><figcaption><em>Observed in this evaluation: the same gate instructions with different question-tool entries. The successful run required both a workflow decision and a separate runtime permission for the command.</em></figcaption></figure><h4>Delegating a task does not guarantee its tools and instructions follow</h4><p>A main agent can delegate work to a specialist subagent. That is useful for separating planning, implementation, or review, but it adds another place where assumptions can fail.</p><p>In the tested delegation, tools listed by a subagent but absent from its parent’s tool list were unavailable. To make a required tool available in that configuration, include it in both lists. Give the parent the tools its delegated tasks need, rather than enabling every tool by default.</p><p>Workspace instructions needed attention too. Instructions available to the main agent did not automatically reach the tested subagents. Runs configured with include-custom-instructions: true did receive them.</p><p>The field worked in these runs, but <a href="https://code.visualstudio.com/docs/agents/reference/custom-agent-file-reference#copilot-specific-configuration">VS Code’s documentation</a> says it does not pass this field through when converting agent files for the Copilot runtime. The reason for that difference remains unresolved. Verify that your delegated agent actually receives the instructions.</p><p>A practical check is to put a unique, harmless marker in the instructions file and ask the delegated agent to quote it from its existing context, without opening the file. Keep the marker itself out of the task prompt. This checks whether the text reached the agent; a separate behavior check is needed to establish whether it follows the rule.</p><p>For a workflow that depends on project rules and external tools, these differences matter. A specialist can produce a plausible response while missing the tool needed to verify it, or the project rule meant to constrain its work.</p><p>One subagent reported that it had terminal and search tools. A follow-up capability test contradicted that report: those tools were unavailable. That is why an actual tool call is stronger evidence than an agent’s description of its capabilities.</p><h4>Context choices can change the cost of a small task</h4><p>A short task could also carry a large amount of setup context.</p><p>In one paired run on my account, two subagents used the same model for a small reporting task. The agent with a narrow tool list consumed <strong>0.78 credits</strong>; the one with a wider list consumed <strong>7.22 credits</strong>. Credits here are the usage units recorded by Copilot.</p><p>Preloaded skills also increased input and credit usage in a separate comparison. Skills supply reusable instructions and resources, so loading substantial material into each new subagent can add to its setup cost.</p><p>That does not establish that the Copilot harness is always more expensive than Local. It does mean that a budget measured under one setup should not be assumed to hold under another.</p><p>Choose tools and skills for the task, then measure a representative run. A narrow tool list still has to include what delegated work needs; removing a required capability to reduce context would defeat the purpose.</p><h3>A practical migration sequence</h3><p>If you mainly use built-in chat and coding features, there may be little custom configuration to move. The more your workflow depends on agent files, reusable prompts, integrations, and approval rules, the more useful a deliberate review becomes.</p><p>Start with a small task whose expected result, tools, and approval steps are known. Then work through five checks.</p><p><strong>1. Identify the harness actually running.</strong> In the editor, <a href="https://code.visualstudio.com/docs/agents/run/agent-harnesses#identify-your-current-harness">check the harness prefix in the chat title</a>. For a new chat, review the Session Target control. Choosing a different model does not switch the harness.</p><p><strong>2. Inventory the workflow’s dependencies.</strong> Include custom agents, workspace instructions, prompt files, skills, external tools, hooks, and any scripts that track approvals or usage. Include personal configuration outside the repository, since a repository-only review can miss it.</p><p><strong>3. Use the migration tooling, then review the result.</strong> VS Code provides <a href="https://code.visualstudio.com/docs/agent-customization/migrate-customizations">migration assistance</a>, currently marked experimental. Prompt files need conversion to skills; personal customizations may need new locations; hooks require manual review. A conversion can also omit prompt-specific model or tool selections.</p><p>Check MCP integrations — the connections to external tools and services — separately. In the evaluation, servers configured with VS Code’s ${input:…} prompts were not passed to the Copilot harness. Verify how the replacement obtains any required credentials, then test an actual tool call.</p><p>The migration review also listed prompt files and MCP configuration, but did not flag the agent that lost its question tool. Review the running agent’s tools even when the migration list shows no issue with its file.</p><p><strong>4. Run one representative workflow through its decision points.</strong> Choose something small that exercises the dependencies you rely on. Check the successful path, a declined or cancelled approval, and a missing dependency. Confirm that delegated agents receive their instructions. Ask them to <strong>call a required tool</strong>, not merely list their tools, using a harmless operation or test environment. Verify the resulting files or command outputs as well as the conversation.</p><p><strong>5. Measure behavior and usage again.</strong> Use <strong>Chat: Export Chat…</strong> to inspect the recorded tool activity, approval events, and usage alongside execution logs. For workflow gates, check the actual question and response as well as the runtime approval events. These records resolved several cases in the evaluation where an agent’s own description was inaccurate.</p><p>A converted file is a starting point. The migration is ready when a representative run produces the expected output, uses the required tools and instructions, and handles its human decisions correctly.</p><p><strong><em>Research note:</em></strong><em> My hands-on findings come from November 12, 2026, on macOS with VS Code 1.146.0, Copilot Chat 0.74.0, and Claude Sonnet 5.5 at Medium effort for the main sessions. The evaluation used one machine and account, with mostly single runs per probe; it did not validate a complete production migration. The findings describe that setup, not every model or future release. Official documentation was rechecked on November 13, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=75b1c373a181" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Is Rosetta and What Does It Add to an AI Coding Agent?]]></title>
            <link>https://medium.com/@mbckchamathsilva/what-is-rosetta-and-what-does-it-add-to-an-ai-coding-agent-8d094a080e6c?source=rss-10f03e678c00------2</link>
            <guid isPermaLink="false">https://medium.com/p/8d094a080e6c</guid>
            <category><![CDATA[rosetta]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[coding-agents]]></category>
            <dc:creator><![CDATA[Chamath Silva]]></dc:creator>
            <pubDate>Sat, 17 Oct 2026 06:28:39 GMT</pubDate>
            <atom:updated>2026-10-17T06:58:48.726Z</atom:updated>
            <content:encoded><![CDATA[<h4>A practical introduction to the gaps it addresses, the pieces it connects, and the way it guides engineering work.</h4><figure><img alt="Illustration of a developer reviewing an expense request beside layered project documents and a code repository." src="https://cdn-images-1.medium.com/max/1024/1*_UBx4EV5rz-tK6OYCayYgg.png" /><figcaption>A developer reviews a request beside layered project documents and a code repository.</figcaption></figure><p>Imagine asking a coding agent: “<em>Let an employee delete an expense submission</em>.”</p><p>The agent may have everything it needs to write an endpoint and a test. But the request leaves important questions unanswered. Can an employee delete an approved expense? Should the record disappear permanently? Must an audit trail remain? Who decides?</p><p>Those questions are part of implementing the right feature. They depend on the project and its policies, not just the model’s ability to generate code.</p><p>Grid Dynamics’ <a href="https://github.com/griddynamics/rosetta">Rosetta</a> is an instruction framework for coding agents. It tries to make that surrounding engineering work more explicit and reusable: how to find project context, clarify a request, plan work, involve people, review changes, and validate the result.</p><p>This introduction explains that approach. It uses Rosetta’s 3.1.16 source snapshot from October 15, 2026, to describe the design. My separate hands-on evaluation used a frozen 3.1.13 build; the later articles examine what actually happened in those runs. <strong>I am an independent evaluator with no association with Grid Dynamics or Rosetta.</strong></p><h3>The gap between generating code and completing engineering work</h3><p>A coding agent brings a model and tools for working with a repository. It can inspect files, propose changes, run commands, and use the capabilities its host provides. That does not automatically give it the company’s retention policy, the project’s architectural decisions, or evidence that someone approved a design.</p><p>Rosetta’s stated purpose is to help make engineering knowledge and practices available across projects and coding tools. I find it useful to group the gaps it targets into five areas. These are explanatory categories, not an official five-part product taxonomy.</p><figure><img alt="Table of five gaps Rosetta aims to address: missing project context, inconsistent working practices, repeated instruction writing, decisions lost between sessions, and uneven verification. Each row pairs an example problem with Rosetta’s intended response." src="https://cdn-images-1.medium.com/max/1024/1*5CncGQC9QGZT59qlgkkJyA.png" /></figure><p>These are gaps Rosetta tries to address. A generated <a href="https://github.com/griddynamics/rosetta/blob/a95d97991ef22e20d979011e010c4eabc6b76e04/docs/CONTEXT.md">context document</a> can still be wrong, and an agent can still skip an instructed step. <strong>The presence of a framework is not evidence that a particular task succeeded.</strong></p><h3>Where Rosetta sits</h3><p>There are three participants to keep in view: the developer, the coding agent, and the project repository. Rosetta provides a shared instruction library that the coding agent uses while working on that repository.</p><p>The developer supplies intent, business knowledge, and decisions. The host, such as Claude Code or another supported coding tool, provides the model, file access, command execution, permissions, and available subagent capabilities. The repository holds the application and its project-specific knowledge.</p><figure><img alt="Diagram showing how the developer, Rosetta, a coding-agent host, and the project repository fit together. The developer supplies intent and decisions; Rosetta supplies instructions; the host supplies the model, tools, and permissions; the agent works with the repository." src="https://cdn-images-1.medium.com/max/1024/1*Q3WWIy1MJoWP2iHqbB_ncw.png" /><figcaption><em>Rosetta guides the work through instructions. The coding-agent host supplies the model, tools, and execution permissions.</em></figcaption></figure><p>Rosetta describes a way to coordinate that work. It is not a new coding model or a replacement for the host. Its <a href="https://github.com/griddynamics/rosetta/blob/a95d97991ef22e20d979011e010c4eabc6b76e04/docs/ARCHITECTURE.md">plugin generator</a> adapts instruction files to the formats expected by different hosts. That makes reuse possible, but it does not mean every host will behave identically.</p><p>Coding agents can already support project instructions, planning, and review. Rosetta proposes to package and connect such practices into a maintained system, so each developer does not have to assemble the entire process from scratch. Whether that additional structure is worthwhile depends on the work and the practices a team already has.</p><h3>The pieces, explained through one feature</h3><p>Return to the expense-deletion request. Rosetta organizes its instructions into <a href="https://github.com/griddynamics/rosetta/blob/a95d97991ef22e20d979011e010c4eabc6b76e04/OVERVIEW.md">different kinds of components</a>:</p><ul><li><strong>Rules</strong> describe standing expectations. For this example, a rule might tell the agent to treat destructive changes carefully and avoid assuming approval.</li><li><strong>Skills</strong> explain how to perform a particular activity, such as assessing risk, writing a plan, or reviewing code.</li><li><strong>Workflows</strong> connect activities in an intended sequence, with inputs, outputs, and decision points.</li><li><strong>Subagent definitions</strong> describe specialist roles, such as an architect, implementation engineer, reviewer, or validator. The host supplies the mechanism for running those roles.</li></ul><p>Project documents supply another essential ingredient. A shared risk-assessment skill can remind the agent to ask about retention; it cannot invent the correct retention policy for your application. That policy needs to come from an authoritative project source or a human decision.</p><p>The components therefore have different jobs: project context explains what matters here; rules and skills guide how to work; workflows connect the steps; specialist roles divide responsibilities. This expense example is illustrative, not a report of a successful experiment.</p><h3>What happens when you use it?</h3><p>There are two stages that are easy to confuse: preparing the repository and carrying out a task.</p><p>During <strong>repository initialization</strong>, the agent inspects the project and creates or updates context files. These can describe the business purpose, architecture, dependencies, assumptions, and implementation state. People still need to check that the generated descriptions are correct. The <a href="https://github.com/griddynamics/rosetta/blob/a95d97991ef22e20d979011e010c4eabc6b76e04/instructions/r3/core/workflows/init-workspace-flow.md">initialization workflow</a> also calls for a fresh chat before subsequent work.</p><p>During <strong>a task session</strong>, startup instructions prepare the agent to use Rosetta and load project context. Task-specific instructions are then brought in as needed. Rosetta calls this progressive loading: start with common instructions, then load the relevant skills and workflow material. It is a context-management design, not proof of lower token consumption.</p><p>For our example, a simplified full-workflow journey would look like this:</p><ol><li><strong>Understand the request.</strong> Read the project context and identify missing deletion rules.</li><li><strong>Agree on behavior.</strong> Establish who can delete which records, what happens to retained data, and what errors callers should receive.</li><li><strong>Design and plan.</strong> Describe the intended behavior and implementation approach, review them, and obtain the required approvals.</li><li><strong>Implement and inspect.</strong> Change the application, check the implementation, and address review findings.</li><li><strong>Test and validate.</strong> Exercise the agreed scenarios and examine whether the result actually meets the requirements.</li><li><strong>Record the outcome.</strong> Update the project artifacts and progress information so later work can continue from an accurate state.</li></ol><figure><img alt="Simplified expense-deletion workflow: read project context, clarify requirements, plan and approve, implement, review and validate, then update project records. Findings can send work back to earlier steps." src="https://cdn-images-1.medium.com/max/1024/1*t7HUBZA0iO9rZrvja8leLw.png" /><figcaption><em>A simplified intended process, not guaranteed behavior. Some review and approval steps are combined. Records should be kept current throughout; findings may require revisiting requirements or design as well as code.</em></figcaption></figure><p>This is an explanation of the logic, not an exact phase list. The <a href="https://github.com/griddynamics/rosetta/blob/a95d97991ef22e20d979011e010c4eabc6b76e04/instructions/r3/core/workflows/coding-flow.md">full coding workflow</a> includes additional review and approval points, scales some steps by task size, and allows adjustments for test-driven development. Failed checks should lead to corrections and further verification.</p><h3>Three choices when using Rosetta</h3><p>Installation, task routing, and process depth are separate decisions:</p><figure><img alt="Table separating three choices when using Rosetta: installation through a plugin, MCP, or local files; task routing through a plain request or workflow command; and process depth through a full or lighter package and workflow." src="https://cdn-images-1.medium.com/max/1024/1*A1DkL6k3UWZhJrRKi2tz9A.png" /></figure><p>A plain request uses startup guidance and relevant skills, but does not automatically invoke a full workflow. <a href="https://github.com/griddynamics/rosetta/blob/a95d97991ef22e20d979011e010c4eabc6b76e04/docs/ARCHITECTURE.md#bootstrap-flow">/rosetta</a> routes a request to a workflow; /coding-flow asks for that workflow directly. Command names and namespaces vary by host and package, and individual skills may also be available.</p><p>Rosetta recommends a plugin for most users. It places instructions in local files for a supported host, installed through a marketplace or a host-specific package.</p><p>Model Context Protocol (MCP) delivery serves instructions through a configured connection; its HTTP and STDIO setups appear as separate columns in the <a href="https://github.com/griddynamics/rosetta/blob/a95d97991ef22e20d979011e010c4eabc6b76e04/INSTALLATION.md#choose-your-mode">installation guide</a>. STDIO runs a local process but does not make the complete setup offline.</p><p>The local-file option is more manual, and raw instruction files have a different layout from a manually extracted plugin. Local Rosetta files also do not make a cloud-based coding model offline.</p><p>The inspected release offers full and lightweight plugin variants, plus a <a href="https://github.com/griddynamics/rosetta/blob/a95d97991ef22e20d979011e010c4eabc6b76e04/instructions/r3/core/workflows/coding-light-flow.md">lighter coding workflow</a>. The variants can request different specialist models; the lighter workflow combines some preparation and review stages. Neither is permission to skip arbitrary checks, and these options do not establish measured cost savings or equivalent quality.</p><h3>The pattern behind the design</h3><p>The design combines several familiar engineering practices: store shared knowledge outside individual conversations, divide work into smaller responsibilities, make decisions explicit, and check results against agreed expectations.</p><p>It also separates reusable process from project-specific facts. A planning skill can apply across repositories; an expense-retention requirement belongs to the expense application. Loading instructions progressively is intended to bring the relevant material together when needed.</p><p>Saving artifacts extends that idea across sessions. A new session can read a plan instead of reconstructing every earlier discussion. But a plan saying “approved” is not automatically proof that the right person approved it. Useful continuation depends on accurate, current records and a way to verify the decisions they describe.</p><h3>What it can and cannot promise</h3><p>Rosetta can give a team a common, inspectable starting point for AI-assisted engineering. That structure may be useful when project knowledge is scattered, requirements need clarification, or multiple people want a repeatable working process.</p><p>That does not guarantee fewer defects, reliable approvals, or better results for every task. In the inspected 3.1.16 full packages, the <a href="https://github.com/griddynamics/rosetta/blob/a95d97991ef22e20d979011e010c4eabc6b76e04/plugins/core-claude/hooks/hooks.json">Claude hook configuration</a> and <a href="https://github.com/griddynamics/rosetta/blob/a95d97991ef22e20d979011e010c4eabc6b76e04/plugins/core-codex/.codex-plugin/hooks.json">Codex hook configuration</a> register session-start context; they do not intercept each tool call. <strong>An instruction to request approval and a host permission check that prevents execution are different controls.</strong></p><p>This structure also needs maintenance. Generated documents need review, shared instructions need updating, and the chosen workflow needs to fit the task. A team with strong existing instructions may find parts overlap with what it already does.</p><p>The question I would bring to an evaluation is: which gap in our current way of working would this structure address, and what evidence would show that it helped?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8d094a080e6c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Enterprise Architecture Needs to Decide About AI Coding Agents]]></title>
            <link>https://medium.com/@mbckchamathsilva/what-enterprise-architecture-needs-to-decide-about-ai-coding-agents-1062f7105925?source=rss-10f03e678c00------2</link>
            <guid isPermaLink="false">https://medium.com/p/1062f7105925</guid>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Chamath Silva]]></dc:creator>
            <pubDate>Thu, 24 Sep 2026 21:27:15 GMT</pubDate>
            <atom:updated>2026-09-24T21:32:41.298Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*crWV6FiyogVxQ9Ey2VLa3g.png" /><figcaption>AI-generated conceptual illustration</figcaption></figure><p>An agent can write a change, run tests, and open a pull request while a team is still deciding what should happen to existing data. The code may look coherent even when that decision remains open. Someone still has to establish the right behavior, decide what the agent may access, and judge whether the change is safe to release.</p><p>This is where enterprise architecture becomes more important. It defines the boundaries within which faster implementation can produce a dependable result. The goal is to make intent, access, and evidence clear enough that teams can move quickly without losing track of what they are accepting.</p><p>Enterprise architects <strong>should agree with platform and security teams on shared rules for agent access, permitted data use, and required release checks</strong>. Within those rules, product and service owners should define the behavior of each change, decide whether its evidence is sufficient, and own recovery if it fails.</p><p>The <a href="https://cloud.google.com/blog/products/ai-machine-learning/announcing-the-2025-dora-report"><em>2025 DORA research</em></a> offers a useful caution. It reports a positive relationship between AI adoption and delivery throughput, alongside a negative relationship with delivery stability. These are associations across the surveyed teams, not proof that a tool caused either outcome. They show why more code output is an incomplete measure of progress.</p><h3>Start with a contract the agent can work against</h3><p>An agent can produce a plausible implementation from an incomplete request. The missing part often appears later, when a user takes an unexpected path or existing data does not match the happy case. Better prompts alone will not solve that. <strong>The team needs a shared description of what the system must do.</strong></p><p>That description can be small. For each change, identify the user outcome, the important business rules, the systems involved, the cases that must fail safely, and what is outside scope. Acceptance criteria should describe observable behavior, including effects on stored data, rather than merely restating the requested code change.</p><p>Suppose a team asks an agent to remove inactive accounts. “Inactive” needs a definition. Are accounts with pending payments excluded? What happens to audit records? Can the operation be reversed? The agent may implement a reasonable answer to each question, but those are product and architecture decisions. They need owners before the implementation becomes a release candidate.</p><p><a href="https://github.com/github/spec-kit/blob/main/docs/concepts/sdd.md"><em>GitHub’s Spec Kit</em></a> describes a workflow that develops intent through specifications, plans, and tasks. The useful principle is that a specification remains visible as work moves into implementation. A particular file layout is optional. What matters is that the requirement can be compared with the code and the tests when someone reviews the change.</p><h3>Decide what the agent can see and do</h3><p>More context can help an agent make a better change. It can also expose data and actions the task never required. Enterprise architecture has to answer a practical question for each workflow: what may this agent read, change, and send outside its environment?</p><p>The <a href="https://modelcontextprotocol.io/docs/2026-07-28/learn/architecture"><em>Model Context Protocol</em></a> gives applications a standard way to discover and call tools and read resources. That is useful integration plumbing. It does not, by itself, decide which tool an agent should be authorized to use, whether a retrieved document is trustworthy, or whether a proposed write is acceptable. Those decisions belong in the surrounding application, identity system, and review process.</p><p>An agent preparing a design may need read access to repository files and internal documentation. An agent changing code may need a writable workspace and test commands. Neither task automatically needs production credentials. Scope access to the job, keep credentials out of the agent’s execution environment where possible, and give high-impact actions their own approval path.</p><p>This matters because an agent may encounter instructions hidden in the material it reads. <a href="https://genai.owasp.org/llmrisk/llm01-prompt-injection"><em>OWASP’s prompt injection guidance</em></a> includes attacks carried through external files and web pages. A retrieved document should remain task data even when it asks the agent to change course. Model instructions help, but the stronger boundary is to limit what a misdirected agent can actually do. <a href="https://www.anthropic.com/engineering/how-we-contain-claude"><em>Anthropic’s account of its agent containment work</em></a> shows why sandbox, filesystem, and network controls are part of the design rather than a final security check.</p><h3>Make acceptance depend on evidence</h3><p>When implementation becomes faster, review can become the limiting step. Adding another agent to review a change may help find mistakes, but agreement between two agents is not enough. Both can follow the same incomplete assumption.</p><p>Start with the rule the change is meant to satisfy. Then ask what evidence would reveal a violation: a test for a rejected input, a check against existing data, a transaction that must roll back, or a user-visible result that must match stored state. Review the complete operation as well as the changed function. <strong>A passing test is useful only when it could have failed for the behavior that matters.</strong></p><p>The reviewer should also check changes to tests and acceptance criteria against the agreed requirement. A passing result is weak evidence if the implementation changed what counts as success. Changes to required checks need independent approval, enforced through repository and CI permissions that the implementing agent cannot bypass.</p><p>This does not require every pull request to carry a large formal specification. For a low-risk change, a clear requirement and targeted tests may be enough. For work involving money, access, tenant isolation, or irreversible data changes, the evidence should be stronger. The review record should connect the requirement, the implementation, the tests, and any remaining uncertainty so the person approving the change knows what has actually been checked.</p><h3>Carry the same rules into deployment and maintenance</h3><p>AI can help draft tests, inspect logs, and propose fixes after release. Those uses still need boundaries. A production diagnosis made from telemetry is a hypothesis until someone checks the system state and the proposed remedy. A generated rollback script deserves the same scrutiny as any other production change.</p><p>Architecture should make the path from request to outcome traceable. A team should be able to find the decision behind a change, the evidence used to accept it, and the signal that would show a problem in production. Existing ticketing, CI, incident, and audit systems can hold that record; teams do not have to replace them with a new collection of Markdown files. They do need to agree which record is authoritative and keep links between the artifacts.</p><p>Frameworks can help organize this work. The <a href="https://www.nist.gov/itl/ai-risk-management-framework"><em>NIST AI Risk Management Framework</em></a> is a voluntary way to govern, map, measure, and manage AI risks. <a href="https://www.iso.org/standard/42001"><em>ISO/IEC 42001</em></a> defines requirements for an AI management system. Using either does not establish that a particular generated change is correct. The value for an engineering team is in turning general risk responsibilities into specific owners, controls, and evidence for its own systems.</p><h3>Adopt according to the risk of the workflow</h3><p>Company size alone is a poor guide to how much autonomy an agent should have. A small company handling sensitive records may need tighter controls than a large company updating an internal documentation site. The relevant questions are what the agent can reach, how a failure would affect users, how well the change can be tested, and whether the team can recover.</p><p>A more useful starting point is the workflow itself:</p><ul><li><strong>Assistance</strong>: Let an agent analyze, explain, and propose changes while a person performs the write and review.</li><li><strong>Bounded execution</strong>: Let it edit code and run tests in an isolated workspace, then submit a change for independent review.</li><li><strong>Delegated maintenance</strong>: Let it pick up a preapproved, repeatable class of tasks without a new instruction for each one, then submit pull requests for review. Start only after the team has demonstrated reliable tests, access controls, recovery, and monitoring for that class.</li></ul><p>In these modes, designated human reviewers retain approval of merges and deployments. The service owner remains accountable for recovery and must route requests outside the agreed scope to whoever owns the affected policy before work proceeds.</p><p>Move between these modes based on evidence from the actual workflow. Track time to an accepted change, review effort, rework, escaped defects, and operational cost. <strong>Token use and pull-request volume can explain the cost and activity of the system; they do not tell you whether it delivered the right result.</strong></p><p>AI can shorten the distance from intent to implementation. The architectural task is to keep the rest of that distance visible: the rules behind the request, the authority granted to the agent, the evidence for accepting its output, and the consequences after release. <strong>A team that can answer those questions has a basis for increasing autonomy. Without those answers, faster code simply creates more decisions for someone else to untangle.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1062f7105925" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Agentic Coding Changed My Bottleneck: From Writing Code to Proving It]]></title>
            <link>https://medium.com/@mbckchamathsilva/agentic-coding-changed-my-bottleneck-from-writing-code-to-proving-it-7126ec515048?source=rss-10f03e678c00------2</link>
            <guid isPermaLink="false">https://medium.com/p/7126ec515048</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[technical-leadership]]></category>
            <category><![CDATA[ai-assisted-development]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Chamath Silva]]></dc:creator>
            <pubDate>Fri, 04 Sep 2026 04:52:52 GMT</pubDate>
            <atom:updated>2026-09-04T05:08:34.946Z</atom:updated>
            <content:encoded><![CDATA[<h4>What repeated evaluations and a repair that needed its own repair taught me about engineering confidence.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q5jdw1qg0i1uy5SF85n_Fw.png" /><figcaption>An inspection of software artifacts, rules, and evidence representing verification of agent-generated code.</figcaption></figure><p>Seven specification documents, running to more than 115,000 words. A custom guard script with 24 named rules. Explicit agent instructions for money, time, tenancy, and writes.</p><p>That was part of the project’s setup by the end of August. There were integration tests and automated pull-request reviews. I also ran repeated static code evaluations using different models.</p><p>The instructions went beyond coding style. They specified how money must be represented, where tenant identity must come from, and which writes had to succeed or fail together.</p><p>I had spent more than a month building the application with coding agents, working alone across requirements, architecture, implementation, testing, and review.</p><p>I’m listing all this to close off the easy objection. <strong>What follows is not what happens when you vibe-code. It’s what happens when you don’t.</strong></p><p>Implementation was fast. New issues kept turning up in evaluations, including cases that weren&#39;t obvious from the main user flows. Each round brought more fixes and more checking.</p><p>That is where my bottleneck moved: from writing code to establishing what justified accepting it. By “proving it,” I mean evidence for that decision, not a claim that the application has no defects.</p><h3><em>Speed was real; confidence took longer</em></h3><p>That speed mattered while I was handling the whole project myself, and I do not want a discussion of the failures to obscure that benefit.</p><p>But implementing a feature did not settle every question about its behaviour. A main flow might describe what happens when a record is created. Harder cases appeared when the record was corrected later, when another action happened in between, or when related state already existed.</p><p><em>These are familiar software problems. They are not unique to AI just because an agent helped write the code.</em> This project brought into focus the work required to find and resolve them, even within a fast implementation process.</p><p>That verification work belongs in any honest assessment of what the agents helped deliver.</p><h3>The fix can need its own review</h3><p>One deposit correction in the review history is a useful example.</p><p>Some deposits still appeared as held after they had been refunded. The initial explanation pointed to test-data insertion. The recorded investigation instead identified an ordinary correction workflow in the application as the cause. Repairing the existing records would not be enough; the code producing them also needed attention.</p><p>Then the proposed fix needed another correction. A deposit could have been topped up after its original amount was recorded. Refunding the original amount would leave those additional funds held. Marking the whole deposit as released could hide them from a report.</p><p>The revised correction refused that topped-up case and rolled back the changes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QnsmMlepC0Ig__OpGUKeTQ.png" /><figcaption>A deposit workflow showing an original deposit, a later top-up, and a refund that must leave the top-up held</figcaption></figure><p>The original refund can be completed while a later top-up is still held.</p><p><strong>What I take from this is that a correct-looking fix can still depend on an incomplete understanding of the workflow.</strong> The original entry, a later addition, and a correction each sound reasonable on their own. The behaviour across the sequence is what matters.</p><p>For me, that is the architectural lesson: <strong>review the business operation and its consequences, not just the changed function</strong>.</p><h3>What the technical lead still needs to own</h3><p>The first responsibility is making the intended behaviour clear enough to challenge the implementation.</p><p>In the deposit example, the rule is straightforward: money that remains held must remain visible as held. The specification, the code and the tests should all be answerable to that rule. A convincing explanation of the implementation cannot become the definition of correctness.</p><p>There also has to be a place where the rule is enforced. Database constraints, transactions, and checks in application code can all contribute, but their presence alone says little about whether the particular failure is prevented. I want the review to connect the rule to the enforcing code and to a test that could expose its absence.</p><p>Tests themselves need that challenge. In another case in this project, signup assigned a role with no usable interface. Test helpers supplied the role themselves, and an endpoint test accepted the incorrect role as the expected result. The code and the test agreed on the wrong behaviour.</p><p>This is why I see independent verification as more than asking a second model to read the same change. It can mean deriving an expected result from the business rule, testing against existing data, or following an action through to what is stored and displayed. Those checks bring something beyond another explanation of the code.</p><p><strong>Multiple models were useful in my evaluations. They were not a substitute for judgment</strong>. A later evaluation even reported checks as missing when the cited code already contained them. A finding needs checking before it becomes another implementation task.</p><p>Accepting a diagnosis, choosing a remedy, and deciding when to make the change remain engineering decisions. So does deciding how far the evidence reaches: a fix in one path does not establish that every related path is correct.</p><p>The agents can contribute to all of this. <strong>The responsibility for connecting it into a defensible decision still sits with the person leading the work.</strong></p><h3>What I would carry into the next project</h3><p>I have not started another project yet. Before I do, I want these lessons to affect how I structure the work.</p><p>I would give more attention to scenarios around corrections, retries, concurrency, and existing data, rather than treating the main user flows as the boundary of verification. For important rules, I would want evidence that the tests can detect a broken implementation. I would also make room for checks across the complete workflow, including the result a user eventually sees.</p><p>Another lesson is that progress tracking is part of the engineering work. Each finding needs a clear path from discovery to decision, fix, and verification. I want to explore better support for that workflow, although I have not chosen a framework yet.</p><p><strong><em>The main lesson I would share with another technical lead is to plan for the work of establishing confidence as deliberately as the work of implementation.</em></strong></p><p>Coding agents helped me move quickly. What I want to improve now is how I decide that the next change is ready to accept and what evidence I can point to when making that decision.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7126ec515048" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microsoft Entra ID (Azure AD) Based SSO in React Application with Independent Backend Token…]]></title>
            <link>https://medium.com/@mbckchamathsilva/microsoft-entra-id-azure-ad-based-sso-in-react-application-with-independent-backend-token-74583ce64307?source=rss-10f03e678c00------2</link>
            <guid isPermaLink="false">https://medium.com/p/74583ce64307</guid>
            <dc:creator><![CDATA[Chamath Silva]]></dc:creator>
            <pubDate>Tue, 20 Aug 2024 05:04:33 GMT</pubDate>
            <atom:updated>2024-08-20T20:32:56.625Z</atom:updated>
            <content:encoded><![CDATA[<h3>Microsoft Entra ID (Azure AD) Based SSO in React Application with Independent Backend Token Validation</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u9dJbRPLDWXyMnceikl6cg.jpeg" /><figcaption>The image was generated using DALL-E through OpenAI’s ChatGPT.</figcaption></figure><p>In today’s world of distributed systems, securing your applications with Single Sign-On (SSO) and ensuring proper API authentication is crucial. This article will guide you through the process of implementing <strong>Microsoft Entra ID (Azure AD) based SSO</strong> in a React application, handling tokens securely, and <strong>validating those tokens in an independent backend</strong> hosted on AWS. I encountered several challenges during this implementation, including issues with token validation, and I have found solutions that can benefit others facing similar scenarios.</p><p><strong>In this first part of the series</strong>, we will cover:</p><ul><li><strong>An Overview of the Use Case, </strong>including the architecture and design considerations.</li><li><strong>Setting Up Microsoft Entra ID for SSO</strong>, which lays the foundation for secure authentication in your React application.</li></ul><p>In <strong>the following article</strong>, we’ll dive into:</p><ul><li><strong>Integrating Microsoft Entra ID SSO in React with MSAL</strong>, where we’ll implement the authentication flow in your React app.</li><li><strong>Validating Tokens in the Independent Backend</strong>, ensuring that your backend securely processes and validates the tokens issued by Microsoft Entra ID.</li></ul><p>By the end of this series, you will have a complete solution for implementing SSO and token validation across distributed systems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7HbfVqYb63l-wogiltHe8g.png" /><figcaption>High Level Architecture</figcaption></figure><h3>1. Overview of the Use Case</h3><p>When building modern applications, you often need to integrate different technologies while maintaining high security. In my project, I needed to:</p><ul><li>Implement SSO in a React application using Microsoft Entra ID.</li><li>Securely use the tokens obtained from Microsoft Entra ID to access independent backend APIs hosted on AWS, which has no direct relationship with Azure.</li></ul><p>The goal was to ensure that the backend could validate tokens and grant access based on the scopes and claims provided by Microsoft Entra ID.</p><h3>2. Setting Up Microsoft Entra ID for SSO</h3><p>To get started, you must register your React application and backend API using Microsoft Entra ID. This involves creating two separate Microsoft Entra ID applications: one for the React frontend and another for the backend API.</p><h4>Step 1: Register the React Application</h4><ol><li><strong>Access Microsoft Entra ID</strong>: Sign in to the Azure Portal and navigate to <strong>Microsoft Entra ID</strong> (formerly Azure AD).</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QeTzz79NEfbda3YUASVpSg.png" /></figure><p><strong>2. Register a New Application</strong>:</p><ul><li>Go to <strong>App registrations</strong> and click <strong>New registration</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4tIDQJjTwdWheQ287Gt_1A.png" /></figure><ul><li>Provide a name for your app, such as <strong><em>“React Frontend App.”</em></strong></li><li>Configure the necessary <strong>Redirect URIs</strong> (e.g., <a href="http://localhost:3000/">http://localhost:3000</a> for development).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1Cq3kAJgCL7eTM7whaxICQ.png" /></figure><p><strong>3. Save the Application (client) ID</strong>:</p><ul><li>After completing the registration, note the <strong>Application (client) ID </strong>and<strong> Directory (tenant) ID</strong>. You’ll need this when configuring MSAL in your React app.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eH80JaVMRtQnAsxUWWgX9g.png" /></figure><h4>Step 2: Register the Backend API</h4><ol><li><strong>Register a New Backend API</strong>:</li></ol><ul><li>In <strong>Microsoft Entra ID</strong>, go to <strong>App registrations</strong> and click <strong>New registration</strong>.</li><li>Name your app something like <strong><em>“API Backend.”</em></strong></li><li>Leave the <strong>Redirect URI</strong> and <strong>Supported account types</strong> with their default values.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZiS61pfTirP2JmmGs0boWw.png" /></figure><p><strong>2. Expose the API</strong>:</p><ul><li>Under the <strong>Manage</strong> section, select <strong>Expose an API</strong>.</li><li>Next to the <strong>Application ID URI</strong>, click the <strong>Add</strong> link. You can either keep the default GUID or replace it with a unique identifier (e.g., backend-api-v1). Click <strong>Save</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dfF-iGMWDT2v48zt4iaRgw.png" /></figure><p><strong>3. Define Scopes for the API</strong>:</p><ul><li>Under <strong>Scopes defined by this API</strong>, click <strong>Add a scope</strong>.</li><li>For the <strong>Scope name</strong>, enter a name like full_access.</li><li>For the <strong>Admin consent display name</strong>, enter something user-friendly like <strong>“Access to React SSO Application.”</strong></li><li>For the <strong>Admin consent description</strong>, provide a brief description, such as <strong>“Grants full access to the React SSO Application.”</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pqq9qAUQIrYOE-WTTY7esg.png" /></figure><h4>Step 3: Add Backend API Permissions to the React App</h4><ol><li><strong>Go to the React Frontend App</strong>:</li></ol><ul><li>Return to the app registration for your React frontend app (created in Step 1).</li></ul><p><strong>2. Add API Permissions</strong>:</p><ul><li>In the left-hand menu, click <strong>API Permissions</strong>.</li><li>Click <strong>Add a permission.</strong></li><li>In the<strong> “Request API permissions” </strong>pane, select<strong> My APIs </strong>or<strong> APIs my organization uses.</strong></li><li>Find and select your<strong> <em>backend API </em></strong>(created in Step 2)<strong>.</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mrIPU-CUmL0ExpRK4D0J6Q.png" /></figure><ul><li>Choose the custom scope you created<strong> (e.g., <em>full_access</em>), </strong>and add it to your React app.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DY3groB5VtIjBFJeBRtROw.png" /></figure><p><strong>3. Grant Admin Consent</strong>:</p><ul><li>After adding the permission, click <strong>Grant admin consent for [Your Tenant Name]</strong> to apply the permission across your organization, ensuring that users won’t be prompted to consent individually.</li></ul><p><strong>4. Copy the Scope Name</strong>:</p><ul><li>In the <strong>Configured permissions</strong> list, locate your newly added scope.</li><li>Copy the full scope name (e.g., api://8c3ba0d5–7e05–441b-813c-1af48bc42330/full_access). You’ll need this when configuring MSAL in your React app.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4MP7nNehKQ_sLEHG-wxcqw.png" /></figure><h4>References</h4><ul><li><a href="https://learn.microsoft.com/en-us/azure/active-directory-b2c/configure-authentication-sample-react-spa-app">Configure authentication in a sample React SPA by using Azure Active Directory B2C</a></li><li><a href="https://learn.microsoft.com/en-us/entra/identity-platform/quickstart-single-page-app-react-sign-in">Quickstart: Sign in to a SPA &amp; call an API - React - Microsoft identity platform</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=74583ce64307" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>