Chinese
Uncategorized

GPT-6.2 in GitHub Copilot Turns Model Choice into a Review Policy

GPT-6.2 is now in GitHub Copilot. The practical question is how teams turn model choice into a review and cost policy.

Jacky Wang 4 min read 30 views

Last week I looked at an Agent-written change where the hard part was not asking for more code. It was deciding whether the change had misunderstood the boundary of the problem. As models get better at producing code, a review cannot be reduced to counting changed lines.

On November 17, GitHub announced that OpenAI’s GPT-6.2 Astra and GPT-6.2 Sol were generally available in GitHub Copilot. The rollout covers entry points including VS Code, Copilot CLI, the coding agent, and GitHub.com. GitHub describes Astra as the newer model for agentic coding and terminal work, while Sol is aimed at complex agentic coding and deeper code review. The same announcement says that, in early testing, Sol found nearly twice as many real issues as GPT-6.1 Sol in code review, while Astra completed agentic tasks using noticeably fewer tokens. Those are GitHub’s early-test claims, not a benchmark I ran, and they should not be translated directly into a production defect rate. GitHub Changelog

Model choice belongs next to task policy

The useful shift is that model selection starts to look like an engineering policy rather than a personal preference. I would not automatically send a one-line test fix, a documentation edit, or a disposable script to the most expensive model. I would make a different call for a database migration, an authorization change, a payment path, or a Kubernetes deployment. A cheap model that creates half a day of rollback work is not cheap in the way a billing dashboard suggests.

For a small team, the policy can be plain text before it becomes automation:

small change       -> fast model, human review required
cross-module bug   -> Astra, tests and diff review required
auth / data / prod  -> Sol, two reviewers, no auto-merge

That is my proposed convention, not a GitHub configuration format. GitHub says availability is rolling out gradually, and administrators can control access through Copilot model policy. I would check the model picker and the organization settings before documenting a specific default. A model name in a README is not a guarantee that every developer or repository can use it.

Better review signals still need a human

Finding more issues does not mean that a team can skip a review. If an Agent flags a permission bypass, a transaction-order bug, or a missing nil check, I still need to open the surrounding code and confirm that the path is reachable. For uncovered branches, the model’s comment is a lead, not evidence.

My minimum review loop is simple: identify the affected boundary, run the relevant tests, inspect failure and rollback paths, then read the diff again with the original requirement beside it. For Agent-written pull requests I also ask what the change intentionally did not touch. Some of the risky changes are deletions: an Agent removes a guard because it looks duplicated, but that guard was protecting a different caller.

GitHub also says GPT-6.2 models are billed at provider list pricing under usage-based billing. Current plan access and prices belong to the live Copilot documentation, not to a static article.GitHub AI model comparison I would measure the total cost of a task: model usage, review time, test failures, and rework. A lower token count is useful only if the resulting change remains understandable.

What I would ship first

If a repository already uses the Copilot coding agent, I would add model guidance to the pull-request template and document the cases that cannot auto-merge. Generating a PR can be acceptable for a production repository. Merging and deploying it need separate gates: tests, ownership approval, and a rollback plan.

That boundary matters in my Kubernetes work. An Agent can help format a manifest, compare two rollout strategies, or explain a log. It cannot decide that a live service should be restarted. The action has an external cost and needs a person who owns the system.

The next phase of coding agents will be less about whether a model can write a plausible patch. It will be about whether a team can control when it writes, how its work is reviewed, and what happens when the first answer is wrong. I would track why changes are sent back for revision, not just which model tops a leaderboard. If review time does not fall, a stronger model may simply put more polished diffs in front of the same tired humans.

Sources

发表评论