GitHub Copilot Token Optimization

Quick Start

14 things to do right now

Start with output, then shrink structural input, then route models and tools.

Fastest wins

1. Code-only responses: highest per-token ROI.
2. Constrain format: bullets, one sentence, JSON, tables.
3. Shrink always-on context: instructions and agent files.
4. Use Auto by default: pin premium only when justified.
5. Use Ask Mode for simple questions.

More fast wins

6. Scope context with applyTo.
7. Write precise prompts: target file, function, done condition.
8. Retune prompts to target model.
9. Audit MCP servers.
10. Convert rich files to Markdown first.

More fast wins, continued

11. Run /chronicle cost tips & /chronicle improve in Copilot CLI.
12. Use AI Engineering Coach for VS Code habit review.
13. Try CodeAct for long CLI tool chains.
14. Build a Graphify map for repeated codebase navigation.

The priority stack

Lab 0: baseline your habits

Part 1

Why tokens matter

Tokens drive cost, speed, limits, and context capacity.

Tokens are subwords

Cost model

Output tokens usually cost materially more than input tokens in vendor pricing examples.

Input is bigger than your prompt

Context window
├─ System prompt
├─ copilot-instructions.md / AGENTS.md
├─ File context and open tabs
├─ Conversation history
├─ MCP tool schemas
└─ Your typed prompt

Your 20-word prompt can ride inside thousands of hidden tokens.

Coding Agent multiplier

One issue-to-PR run is not one request.

Lab 1: token anatomy

Part 2.1

Prompt compression

Say same thing in fewer tokens. Preserve technical precision.

Caveman pattern

[thing] [action] [reason]. [next step].

Before vs after

Compression levels

Structured beats prose

POST /api/users
Validate:
- name: string, required
- email: string, required, valid
400 on validation fail
201 on success, return created user
Save to DB

Bullets and key-value pairs force clarity and reduce filler.

Code-centric prompting

Guardrails as invariants

Lab 2: prompt compression ladder

Lab 3: prompt A/B

A: Could you take a look at auth and improve error handling?

B: File: src/auth/login.ts.
Bug: null user causes .email crash.
Fix: null guard before .email.
Test: add null-user case.
Done: targeted test passes.

Part 2.2

Language comparison

English is usually most token-efficient for prompts.

CJK assumption fails

Why

• BPE tokenizers are trained heavily on English.
• Common English words often get one token.
• CJK text has fewer characters, but more tokens per character.
• Non-Latin scripts often cost more; transliteration can help.

Practical rule

If a user writes better in native language, quality can outweigh token cost. For optimization, English wins.

Lab 4: tokenizer reality check

Part 2.3

Context management

Control what gets sent. Biggest input wins are structural.

Always-on files cost every turn

.github/copilot-instructions.md, AGENTS.md, CLAUDE.md, and similar files can become persistent context.

Duplicate content can be paid twice when multiple files are loaded by different tools.

Instruction compression example

Terse like caveman. Technical substance exact. Only fluff die.
Drop: articles, filler (just/really/basically), pleasantries, hedging.
Fragments OK. Short synonyms. Code unchanged.
Pattern: [thing] [action] [reason]. [next step].

Around 50 tokens. Loaded on every interaction.

Context hygiene

• Close files not relevant to current task.
• Keep files focused and small.
• Ignore build output, vendor dirs, generated files.
• Use Content Exclusion for sensitive paths in Business/Enterprise.
• Start fresh conversations after topic changes.

Use scoped instructions

---
applyTo: "src/api/**/*.ts"
---
API conventions:
- Routes in src/api/routes/. Handlers thin, logic in services/.
- Validate with zod.
- Errors via Result<T,E>, never throw.

Pay path-specific guidance only when relevant files are in scope.

Always-on vs conditional vs on-demand

Normalize rich files first

Cache-friendly behavior

Persistent graph navigation

Enterprise note: Content Exclusion

Lab 5: context audit

Part 2.4

Output control

Tell model what not to say. Highest per-token ROI.

Default line

Code only, no explanation.

Best for generation tasks when team already understands desired change.

Format constraints

Project default

Be concise. No explanations unless asked.
Code only for generation tasks.
Bullets over paragraphs.

Override when learning, debugging, or teaching: ask for explanation explicitly.

Lab 6: output A/B

A: Add input validation to processOrder().

B: Add input validation to processOrder().
Code only. No explanation. Minimal diff.

Lab 7: format forcing

Part 2.5

Workflow optimization

Use cheaper interaction shapes before optimizing words.

Commit and PR text matter

Ask vs Edit vs Agent

Auto model default

Auto is a good baseline: supported Auto pool, org policy-aware, discount on eligible paid-plan Chat usage per docs.

Auto does not mean "escalate into every premium model." Pin premium deliberately.

Retune prompts when model changes

Target model: GPT-5.5.
Guide: <official prompting guide URL>
Files: .github/copilot-instructions.md, .github/instructions/*.md
Adapt prompts to guide. Preserve behavior. Reduce rework.
Show diff only.

When not to compress

• Security warnings.
• Irreversible operations.
• Onboarding and teaching.
• Regulatory/compliance language.
• Complex instructions where fragments add ambiguity.

Close loop with usage coaching

Plan first, execute cheaply

Lab 8: mode routing drill

Lab 9: model routing drill

Part 2.6

Always-on context problem

More context can make agents worse and cost more.

Research signal

Why context hurts

Keep landmines only

Bug tracker model

Start almost empty.
Agent trips on something -> add one line.
Root cause fixed -> delete that line.

Instruction files should grow and shrink, not accumulate like a wiki.

Lab 10: landmine pruning

Part 2.7

MCP and tool costs

Tool schemas are hidden token tax.

Measure first

/context

System/Tools: MCPs + instructions + system prompt
Messages: conversation history
Free Space: remaining context

In VS Code, estimate active MCP servers x tools x about 200 tokens/tool.

Every tool costs tokens

Multiplication problem

10 MCP servers
x 5 tools each
x 200 tokens/tool
= 10,000 tokens per step

15 agent steps = 150,000 schema tokens

Audit rule

• Disable servers not needed now.
• Use per-workspace config, not global everything.
• Prefer built-in tools over duplicate filesystem MCPs.
• Use skills for occasional capabilities.
• Scope large plugins by namespace/mode when supported.

Tool output compression

rtk init --copilot

snip init --agent copilot

Pick one output filter layer per command path. Do not stack RTK and snip by default.

One tool per layer

Azure MCP case pattern

One large plugin can dominate System/Tools budget.

--namespace appservice --namespace cosmos --namespace keyvault --namespace storage

Scope by service/persona. Avoid "all tools" mode unless truly needed.

Lab 11: MCP audit

Enterprise lab: tool policy

Part 3

Comparisons and data

Use evidence to pick habits with best impact-to-effort.

Same task, different cost

Big winners

1. Caveman-speak + precise prompts.
2. Code-only / constrained output.
3. Shrink always-on context.
4. Ask Mode for simple questions.
5. Audit MCP servers.
6. Retune prompts after model changes.

Quality curve

Savings:  lite ---- full ---- ultra ---- extreme
Risk:     low  ---- low  ---- medium --- high

Sweet spot: full caveman. Maximum return, negligible risk for technical users.

Lab 12: prioritize techniques

Part 4

Practical setup

Turn techniques into repo and team defaults.

Repo setup steps

1. Create compressed .github/copilot-instructions.md.
2. Add compressed project-specific rules.
3. Split path-specific guidance with applyTo.
4. Use Auto by default; pin only with reason.
5. Add copilot-setup-steps.yml for Coding Agent.

Starter instruction template

Terse like caveman. Technical substance exact. Only fluff die.
Drop: articles, filler, pleasantries, hedging.
Fragments OK. Short synonyms. Code unchanged.
Code only for generation tasks. No explanation unless asked.
Minimize tool calls. Batch related reads/edits.

Coding Agent setup

# .github/copilot-setup-steps.yml
steps:
  - name: Install dependencies
    run: npm ci
  - name: Build
    run: npm run build

Prevents discovery by trial and error. Saves agent steps.

Precise issue template

Bug: login fails when email contains "+".
File: src/auth/login.ts, validateEmail() L42.
Fix: URL-encode email before OAuth provider call.
Test: add user+tag@example.com case.
Done: targeted test passes.

Build habit over 4 weeks

Agent mode controls

{
  "chat.agent.maxRequests": 10,
  "github.copilot.chat.agent.model": "auto"
}

Cap runaway sessions carefully. Increase only when task requires it.

Agent mode cost loop

Session harness checklist

model
mode
agent/profile
active MCP/tools
output filter
repo instructions

Choose before the session starts. Stable harness = predictable cost and cache behavior.

Lab 13: repo implementation

Part 4.2

Model selection and pricing

Separate Copilot docs, UBB framing, and vendor token pricing.

Three pricing views

Auto: practical meaning

• Chooses from supported Auto pool.
• Subject to plan and org policy.
• Based on health and performance.
• Discounted on eligible paid-plan Chat usage.
• Does not automatically escalate to every premium model.

Reasoning effort

Use only on models that expose this control.

Anti-patterns

• Leaving premium model pinned all day.
• Assuming Auto jumps to premium when task gets hard.
• Equating vendor API pricing with Copilot billing.
• Enabling every premium model for whole org first.
• Ignoring plan/model availability.

Lab 14: model escalation policy

Part 4.3

Enterprise governance

Admin controls cap spend. Prompt habits improve efficiency.

Spend levers

Prompt compression does not cap spend. It reduces waste inside allowed usage.

Set budgets first

User-level tightening

• Baseline users: low AI-credit budget.
• Power users: higher budget with job need.
• $0 budget: no usage-based features.
• Review monthly and downgrade unused allocations.

Review models before enablement

Instruction scope governance

• Org instructions: broad GitHub.com policy and review reminders.
• Repo instructions: IDE workflow defaults and coding rules.
• Path-specific instructions: local rules where context pays.
• Do not assume org instructions apply everywhere; check docs.

Separate orgs: fallback only

Useful for different model policies or billing boundaries when org structure already matches groups.

Costs: admin overhead, license complexity, user sprawl, SCIM/cost-center constraints.

Measure right thing

1. Which teams exceed baseline?
2. Which users drive AI-credit usage?
3. Which models improve outcomes?
4. Which agent workflows spend without delivery value?

June 1 cutover checklist

1. Move from request counters to AI-credit budgets.
2. Decide pooled vs user-level budgets.
3. Review model availability before premium becomes direct spend.
4. Remind teams completions/next edits stay outside AI-credit billing.
5. Watch long chat and agent workflows first.

Lab 15: budget rollout

Lab 16: governance tabletop

Part 4.4

Outcome per token

Optimize for accepted work, not the shortest prompt.

The metric

A short prompt that causes wrong-direction work is more expensive than a longer plan that lands correctly.

Agentic cost research signal

Outcome loop

Skills as practices

Skill libraries: borrow patterns

Do not install every skill. Load only what changes the next action.

Skill library adoption signal

Stars show attention, not quality. Judge by whether the skill changes the next agent action.

Plan first, execute cheaply

Day-to-day model guidance

1. Auto first for unknown everyday work.
2. Lightweight for tiny bounded work.
3. Mid-tier for normal implementation after clear plan.
4. Powerful for planning, architecture, hard debugging.
5. Fresh session when changing model/tool/agent lane.

Benchmark caveats

• Benchmarks choose candidates; repo tasks choose defaults.
• Harness, tools, retrieval, and reasoning effort affect scores.
• Compare outcome and cost together, not score alone.
• Label sources: verified, directional, anecdotal.

Capstone

30 day token optimization plan

Turn workshop into customer rollout.

Week-by-week rollout

Capstone lab

Final checklist

Closing message