GitHub shipped a small-looking Copilot changelog item yesterday that says a lot about where AI coding is going: enterprise-managed OpenTelemetry export for VS Code and Copilot CLI.
Not a new magical model.
Not another "the agent fixed my bug while I made coffee" demo.
Telemetry.
Which is exactly the kind of boring word that usually means the real work has started.
Organizations can now mandate where Copilot sends OpenTelemetry data, configure the OTLP endpoint and protocol, set service names and resource attributes, add exporter headers, and decide whether prompt, response, and tool content gets captured. The settings can be delivered centrally instead of every developer gluing OTEL_* variables onto a laptop like it is still 2017 and we all enjoy Bash archaeology.
This is not just about dashboards.
It is AI-assisted coding becoming an observable system.
ai coding has escaped the anecdote phase
For the last few years, most arguments about coding assistants have been based on vibes.
One engineer says Copilot makes them faster. Another says it creates review garbage. A manager sees a demo and starts asking why the roadmap is not finished yet. A senior engineer quietly deletes three generated files and pretends not to be annoyed.
Everybody has a story.
Stories are useful, but they do not run an engineering organization.
Once AI coding becomes normal work, teams need to answer normal operational questions. How many agent sessions are actually happening? Which workflows burn the most credits? Which repos get useful pull requests? Which tasks create more review load than value? Which prompts keep causing tool failures?
That is not inspiration.
That is telemetry.
The moment Copilot sessions, model choices, tool calls, costs, and outcomes can be exported into the same observability stack as the rest of engineering, the conversation changes. It moves from "I feel productive" to "show me the shape of the work."
That will make some people uncomfortable.
Good.
the trace is becoming part of code review
The pull request is still important. It shows the final diff.
But the final diff is no longer the whole artifact.
If an agent touched a branch, I want to know how it got there. Which files did it inspect? Which commands did it run? Which tests failed before they passed? Which tools did it call? Did it read the issue carefully or just cosplay as a diligent intern with markdown bullets?
None of this means every PR needs a giant forensic report. Please do not turn code review into airport security.
But for serious work, the process matters.
A generated migration that passes tests after three retries is different from a generated migration that passed because the agent silently deleted the failing test. A dependency update that used the approved package registry is different from one that wandered through the internet.
The trace is where that difference lives.
prompt content is not just debug data
The GitHub changelog detail that jumped out at me is control over whether prompt, response, and tool content is captured.
That is a sharp edge.
Developers put a lot into AI tools. Code snippets, stack traces, customer-shaped examples, internal architecture context, weird secrets that should not be secrets but somehow are.
If telemetry captures too little, it becomes useless. You get counts and durations but no explanation.
If telemetry captures too much, congratulations, you built a compliance incident with nicer charts.
This is why enterprise-managed settings matter. A company should be able to decide what content leaves the tool, where it goes, which collectors receive it, and whether individual developers can override the decision.
That sounds bureaucratic until the first time someone asks whether prompts containing customer data were shipped into a random collector.
Then it sounds like table stakes.
There is also a nice security detail here: managed exporter headers are applied to the Copilot Chat extension exporter and are not passed through environment variables to tool subprocesses. Tokens should not leak into every little process an agent spawns just because observability needed authentication.
The plumbing is not glamorous.
The plumbing prevents the incident.
cost visibility is not finance theater
GitHub also called out clearer cost visibility across sessions, delegated work, and subagent usage in the recent VS Code Copilot releases.
This matters more than teams want to admit.
AI coding cost is slippery because it does not feel like infrastructure. Nobody thinks "I am provisioning compute" when they ask an assistant to refactor a service. But model calls, long sessions, retries, browsing tools, and large context windows all have a bill hiding somewhere.
If the bill only arrives as a monthly surprise, the organization learns nothing.
Cost needs to be attached to units of work while the workflow is still adjustable. Which agent task templates are cheap and reliable? Which ones fail twice before producing something reviewable? Which repos have huge context windows because nobody bothered to define scope?
This is not about shaming developers for using tools.
It is about making the system honest enough to improve.
A good engineering org does not only ask "did the agent produce code?"
It asks "was this a sensible way to spend attention, compute, and review time?"
observability will expose review debt
Here is the uncomfortable part: telemetry will not only show productivity.
It will show waste.
It will show agent sessions that start and never land. It will show expensive runs that produce PRs humans reject. It will show repositories where generated work creates more review cycles than human work. It will show teams where AI usage is high but merge quality is flat. It will show prompts that look successful only because reviewers quietly clean up the mess later.
That is useful data.
Also, nobody will enjoy the first dashboard.
This is the same pattern we saw with production observability. The first time you add real traces, you discover the system is not as elegant as the architecture diagram. The first time you add real metrics, you discover the retry logic is having a private party in the corner.
AI coding will be the same.
Instrumentation will turn vague discomfort into visible workflow debt.
That is when the work gets better.
what i would measure first
If I were rolling this out in an engineering organization, I would avoid the grand dashboard at the beginning. Grand dashboards become monuments to meetings.
Start with a few measurements that connect directly to engineering behavior:
- sessions completed, abandoned, and converted into pull requests
- cost per merged change and rejected change
- review cycles for agent-assisted PRs versus similar human PRs
- tests run, tests skipped, and failures fixed during the session
- tool calls by category, especially package managers, browsers, shells, and internal systems
- model and context-window choices by task type
That is already plenty.
The goal is not to rank engineers by who used the robot most efficiently. Please do not build that cursed spreadsheet.
The goal is to learn which AI workflows deserve automation, which ones need tighter scope, which ones need cheaper models, and which ones should remain a human job for now.
Telemetry should help teams design better work.
Not create another productivity theater dashboard with a logo in the corner.
the punchline
Copilot OpenTelemetry export is a small feature with a big message.
AI coding is becoming operational work.
Once assistants and agents are part of how code is written, reviewed, tested, and shipped, they need the same boring engineering discipline as everything else that touches production: traces, metrics, policies, cost visibility, privacy boundaries, and a way to answer "what happened?" without reading tea leaves from a chat transcript.
The best AI coding platforms will not win only because the model is clever.
They will win because the work is legible.
That means managers can stop arguing from anecdotes. Reviewers can inspect evidence. Security teams can define what telemetry is allowed to contain. Platform teams can see where workflows fail.
The future of AI coding is not just more autocomplete.
It is a trace ID.
Which is hilarious, because after all this hype, we somehow ended up back at observability.
Honestly, that feels about right.
references
- GitHub Changelog: Enterprise-managed OpenTelemetry export for VS Code and CLI
- GitHub Changelog: GitHub Copilot in Visual Studio Code, June 2026 releases
To test my projects, I use Railway. If you want $20 USD to get started, use this link.
Top comments (0)