export const ART_EN10_CONTENT = `
<div class="article-content">
  <p class="lead">GitHub Copilot's move toward token-based billing has generated more confused engineering budget conversations in 2025 than any infrastructure change since AWS introduced reserved instances. If you're not tracking what goes into Copilot's context window, your AI coding costs will surprise you — and the surprises get expensive at team scale.</p>

  <figure style="margin: 0 0 28px 0; border-radius: 10px; overflow: hidden; border: 1px solid #E4DDD2;">
    <img src="/images/articles/ai-data-centric-2026.jpg" alt="GitHub Copilot token billing: context window costs, model selection, and cost optimization strategies" loading="lazy" style="width: 100%; height: auto; display: block;" />
    <figcaption style="font-size: 12px; color: #5F6B6D; padding: 10px 14px; background: #F4EFE6; line-height: 1.7;">Token-based billing for AI coding tools means that what you put in the context window — open files, project-wide context, conversation history — directly drives your monthly bill. Understanding token costs is now a required skill for engineering managers.</figcaption>
  </figure>

  <h2>1. The Billing Model Change: What Actually Changed</h2>
  <p>GitHub Copilot has historically been priced as a flat subscription: $10/month for individuals, $19/user/month for Business, $39/user/month for Enterprise (as of early 2025). These tiers included "unlimited" completions with limitations on which models and features were accessible at each tier.</p>
  <p>In 2025, GitHub introduced <strong>premium requests</strong> — a token-based billing layer on top of the flat subscription. The flat subscription still exists and still covers a baseline of completions using the default model (Copilot's base model, which is distinct from GPT-4o or Claude). The premium request layer applies when you use more capable models: GPT-4o, Claude Sonnet 3.7, and Gemini 1.5 Pro are available as premium model options, and each request to these models consumes premium request credits.</p>
  <p>The Copilot Business plan includes 300 premium requests/user/month at baseline, with additional credits purchasable at $0.04 per premium request. Each premium request is metered in tokens — a request with a 10,000-token context window counts differently than a request with a 1,000-token context window under the underlying model pricing, but GitHub abstracts this into "premium requests" rather than raw token counts. The abstraction is helpful for predictability but obscures where costs are actually being driven.</p>

  <h2>2. What Tokens Are (And Why Code Is Expensive)</h2>
  <p>A <strong>token</strong> is the basic unit of text that an LLM processes. Tokens do not correspond to words one-to-one: common English words are typically 1 token, less common words or words in other languages may be 2–4 tokens, and code is generally more token-efficient than prose because programming language keywords and identifiers are common enough to have efficient token representations. However, the amount of code that goes into context for a completion request is typically much larger than the amount of prose you would include in a chat request.</p>
  <p>When you accept a code completion or ask Copilot a question about your code, the context window includes: the file you are currently editing (potentially thousands of lines), files that Copilot has automatically included based on import analysis ("relevant context"), your conversation history in the chat panel, and the system prompt that Copilot uses to frame the model's role. For large files in a complex project, the context window for a single request can reach 20,000–50,000 tokens.</p>
  <p>The tokenizer used by a model also matters. Claude's tokenizer is notoriously less efficient on code than GPT-4's — a 1,000-line Python file might tokenize to 8,000 tokens with Claude's tokenizer versus 5,500 tokens with GPT-4's. If you're using Claude Sonnet 3.7 as your Copilot model because of its code quality, you may be consuming 30–40% more tokens per request than the equivalent GPT-4o request, which matters under a per-token-cost model.</p>

  <blockquote style="border-left: 4px solid #D49A2A; margin: 28px 0; padding: 16px 20px; background: #D49A2A0A; border-radius: 0 8px 8px 0; font-size: 16px; color: #263238; font-style: normal;">"We didn't change how we used Copilot. We just upgraded to Claude Sonnet as the default model and our premium request usage went up 40% in the first month." — engineering manager, post-mortem thread on Hacker News, 2025</blockquote>

  <h2>3. Why Large Files Are the Biggest Cost Driver</h2>
  <p>The single most impactful variable in your Copilot token costs is file size. Copilot's context assembly includes the current file by default, and for large monolithic files — a 3,000-line React component, a 2,000-line API route file, a 5,000-line configuration schema — the current file alone can exhaust a significant fraction of the optimal context window.</p>
  <p>The irony is that large files are correlated with technical debt: well-structured codebases with good separation of concerns tend to have smaller files, while legacy codebases or rapidly-grown startup code tends toward large files. Teams using Copilot to address technical debt in large files are paying a double penalty — the code quality problem is expensive to fix, and the AI tool for fixing it is more expensive on large files.</p>
  <p>The <strong>multi-file context</strong> feature, which allows Copilot to pull context from files you have open in your editor, multiplies this effect. With three 1,000-line files open, the context can reach 15,000+ tokens before you've typed a single character of your request. This is useful for coherent multi-file refactors, but it means passive IDE usage (having files open) generates token costs differently than actively requesting completions.</p>

  <h2>4. Context Pruning: The High-ROI Optimization</h2>
  <p>The most effective cost optimization strategy for Copilot token billing is controlling what goes into the context window. Several practical approaches reduce context size without reducing completion quality:</p>
  <p><strong>The <code>.copilotignore</code> file</strong> (analogous to <code>.gitignore</code>) tells Copilot which files and directories should never be included in context. For a typical project, the following are high-token, low-value context: <code>node_modules/</code>, <code>dist/</code> or <code>build/</code> directories, lock files (<code>package-lock.json</code>, <code>yarn.lock</code>), generated files (<code>*.generated.ts</code>), and large data files. Adding these to <code>.copilotignore</code> can reduce context by 30–50% for many projects with no impact on completion quality.</p>
  <p><strong>Close unused editor tabs.</strong> Most Copilot IDE extensions include open editor tabs as context candidates. Closing tabs for files you are not actively working on reduces the multi-file context assembly. This sounds trivial but generates measurable cost differences at team scale.</p>
  <p><strong>Scope your questions.</strong> In the Copilot chat panel, questions that reference the entire codebase ("how does authentication work in this project?") trigger broader context assembly than questions scoped to a specific file or function ("how does this function handle token refresh?"). Scoped questions are also more likely to get useful answers.</p>

  <div class="insight-box" style="padding: 14px; border-radius: 10px; background: #0F6B7311; border: 1px solid #0F6B7340; margin-bottom: 20px;">
  <strong>Model Selection Economics:</strong> Copilot's model selection significantly affects both quality and cost. GPT-4o is generally the best balance of cost and quality for inline completions and straightforward chat questions. Claude Sonnet 3.7 outperforms GPT-4o on complex multi-file refactoring and architectural questions but consumes more tokens. For bulk, repetitive tasks (generating test stubs, writing docstrings), consider whether DeepSeek-V3 (available via Copilot's model selection in some configurations) or the default Copilot base model is sufficient — these are significantly cheaper per premium request or not counted as premium requests at all.
  </div>

  <h2>5. Switching to Cheaper Models for Bulk Tasks</h2>
  <p>Not all Copilot tasks require the most capable model. The 80/20 analysis of coding assistant use cases typically shows: 40–50% of requests are inline completions of obvious continuations (finish the function signature, complete the import statement, close a loop body). These do not require GPT-4o or Claude. Another 30% are straightforward single-file tasks: write a unit test for this function, add a docstring to this class, refactor this method to extract a helper. These benefit from a capable model but not necessarily a frontier one.</p>
  <p>The remaining 20% are the high-value, high-complexity requests: architectural analysis, multi-file refactors, debugging complex interactions, generating novel algorithms. This is where GPT-4o and Claude Sonnet 3.7 justify their premium request cost.</p>
  <p>GitHub's model selection in Copilot settings allows switching the default model. The practical configuration for cost-conscious teams: use the Copilot base model (non-premium) as the default for inline completions, with premium models accessible via an explicit model selector for complex requests. This captures the 80% of low-complexity completions without premium request consumption while keeping frontier model access for the 20% of high-value tasks.</p>
  <p><strong>DeepSeek V3</strong> is now available in Copilot's model selection as of early 2025, and its performance on code tasks (HumanEval: 82.6%, comparable to GPT-4o-class performance) combined with its significantly lower inference cost makes it a strong candidate for the middle tier of tasks — more capable than the base model, significantly cheaper than GPT-4o or Claude for bulk work.</p>

  <h2>6. How to Read Your Copilot Bill</h2>
  <p>The Copilot billing dashboard (accessible via github.com/settings/billing for individuals, or organization settings for Business/Enterprise accounts) shows premium request consumption broken down by user and model. The most actionable metric is premium requests per developer per day — this number varies dramatically by workflow and highlights outliers.</p>
  <p>A developer averaging 200 premium requests per day on Claude Sonnet is using approximately 6,000 premium requests per month, which exceeds the Business plan's included 300 premium requests by 5,700 requests — at $0.04 each, that's $228/month in premium request overages for a single developer, on top of the $19/month base subscription. At team scale, this adds up quickly and is rarely surfaced in budget conversations until the bill arrives.</p>
  <p>The ROI calculation that justifies this cost: if the developer is 30% more productive with Copilot (a conservative estimate from controlled studies), and their fully-loaded cost is $200,000/year, the productivity value is $60,000/year — far exceeding even high premium request consumption costs. The argument for controlling costs is not that Copilot is not worth it, but that uncontrolled context growth and model selection can increase costs without proportionally increasing the productivity benefit.</p>
  <p>Best practices for engineering managers: set up monthly billing alerts at 80% of expected premium request budget, review the top-10 premium request consumers each month to identify teams where usage patterns may benefit from coaching (context pruning, model selection), and establish team-level norms for which request types warrant premium model usage.</p>

  <div class="footnote-box" style="padding: 14px; border-radius: 10px; background: #FAF7F0; border: 1px solid #E4DDD2; font-size: 12px; margin-bottom: 20px;">Sources: GitHub, "About GitHub Copilot plans" (docs.github.com/en/copilot, 2025). GitHub Copilot Changelog, "Premium request model rollout" (github.blog, February 2025). DeepSeek, "DeepSeek-V3 Technical Report" (arXiv:2412.19437, December 2024). Chen et al., "Evaluating Large Language Models Trained on Code" — HumanEval benchmark (OpenAI, 2021). Productivity estimates: Peng et al., "The Impact of AI on Developer Productivity: Evidence from GitHub Copilot" (2023).</div>

  <h2>Conclusion: Instrument Before You Optimize</h2>
  <p>GitHub Copilot's token billing shift is not a reason to reduce AI coding tool usage — the productivity evidence is clear that these tools deliver real value. It is a reason to understand what drives the costs and make deliberate choices about model selection, context scope, and usage patterns. The teams that will manage AI coding costs effectively in 2025 are those that instrument their usage first (track premium requests per developer per model), identify the 20% of high-value use cases that warrant frontier model consumption, and configure the remaining 80% to use the most cost-efficient model that delivers adequate quality. The savings are not marginal: for a 20-person engineering team, the difference between thoughtful and thoughtless Copilot configuration can easily be $3,000–5,000/month.</p>
</div>
`;