DEV Community: Wilco Rakhorst

My GitHub Copilot Sessions Kept Degrading -- So I Built a Skill to Fix It

Wilco Rakhorst — Fri, 08 May 2026 09:18:56 +0000

You've probably experienced this. You're 30 minutes into a productive Copilot agent session, things are flowing well -- and then something shifts. The agent asks you to clarify something it already knows. It repeats a question from earlier. The quality of the output quietly drops. You didn't change anything. What happened?

Context ran out.

Every Copilot session has a fixed token budget. Once that budget fills up, the model starts compressing or dropping older context. The result isn't an error message. It's subtle degradation -- and most developers don't even realize it's happening until they're already fighting it.

I built a skill to address this directly. Here's what I learned.

The problem isn't Copilot. It's how we use it.

After tracking a few weeks of agent sessions, I found five recurring patterns that burned through context faster than the actual work:

1. Re-reads
When the same instruction exists in multiple files, the agent reloads it every time it's referenced. I had rules duplicated across copilot-instructions.md and individual skill files. Every time a skill loaded, it brought along content that was already in context. Fix: cross-cutting rules live in references/*.md only. Skills link to them, never copy them.

2. Reading entire files instead of snippets
read_file without startLine/endLine loads the full file -- every time. On a workspace with many skill files, this adds up fast. I also had list_dir calls on the workspace root, which recursively indexed hundreds of paths I never needed.

3. Too many tools active
Every loaded MCP tool takes up space in the system context -- even if it's never called. In agent mode, deferred tools should only be loaded via tool_search when genuinely needed.

4. Working too long in one session
After 15-20 messages, context compression begins. The agent doesn't tell you this. You notice it when output quality drops or earlier decisions get quietly reversed.

5. Trial-and-error tool use
When an agent dives straight into tool calls without a plan, every failed attempt costs double tokens -- once for the call, once for the error. Requiring a written Plan of Action before any tool is invoked eliminates this entirely.

The skill I built

I encoded all of this into a token-hygiene skill:

---
name: token-hygiene
description: "Guidelines for efficient Copilot context management. Use when a session
  is slowing down, the agent is repeating questions, context is filling up, or when
  starting a complex multi-step task. Triggers: 'token', 'context full', 'session
  cleanup', 'new chat', 'load skill', 'terminal risk', 'plan of action',
  'context efficiency'."
version: "1.0"
---

The skill body covers the five causes above, plus a pre-task checklist the agent can consult before starting any complex job:

Check	Action
Is this info already in context?	Don't reload it
Which skills do I actually need?	Load only those -- not preemptively
Am I reading a large file?	Use `startLine`/`endLine`
Searching with a broad term?	Use `grep_search` instead of `semantic_search`
Complex multi-step task?	Write a Plan of Action first
Been working in this session long?	Consider new chat + session memory
Agent repeating a question?	Session is full -- save and restart

The terminal protocol: a surprise lesson

While building this skill, I discovered something that surprised me. The run_in_terminal tool has an explanation parameter described as "This will be shown to the user before the command is run."

That is not true.

The explanation parameter is not visible in the confirmation dialog. It's metadata for the tool system, not a user-facing message. This means if you rely on it to inform users about what a command does, they never see it.

So I added a terminal protocol as a reference file. It requires the agent to write the explanation as a chat message before the tool call -- not after, not inside the tool call. The message must cover:

What the command does in plain language
Which files are read or modified
Whether data leaves the system
Whether the action is reversible

Combined with a risk classification matrix ([LOW] low / [MEDIUM] medium / [HIGH] high / [CRITICAL] critical), this makes every terminal action visible and deliberate.

VS Code indexing: a silent token drain

One thing worth adding to your .vscode/settings.json immediately:

"files.exclude": { "out/": true, "Output/": true },
"search.exclude": { "out/": true, "Output/": true }

VS Code indexes your entire workspace for search. Generated output folders -- HTML reports, screenshots, log files -- get included in search results and can end up as irrelevant context when the agent runs a workspace search. .gitignore doesn't prevent this. Only files.exclude and search.exclude do.

The skill structure

.github/skills/token-hygiene/
  SKILL.md                            # Core skill -- 5 causes, checklist, VS Code tip
  references/
    terminal-protocol.md              # Required transparency rules for terminal calls
    terminal-risk-classification.md   # Risk matrix per command type

The references are loaded on demand -- the agent only reads them when it actually needs to run a terminal command. This follows the progressive disclosure pattern I described in my previous post on reusable marketing skills.

The most useful thing: session memory

The fix I use most often isn't even in the skill itself. At the end of any session longer than 15 messages, I ask:

"Summarize our progress as a short status update."

I paste that into the first message of the new chat. The agent has full context again in one message, without reloading a single file.

manage_todo_list also helps here -- if the agent tracks tasks as it works, you never need to scroll back through the conversation to remember where you are.

Why this matters more than you'd expect

Token hygiene sounds like an optimization problem. It's actually a reliability problem.

When context fills quietly, the agent doesn't fail loudly. It makes slightly worse decisions. It misremembers earlier choices. It starts contradicting itself in subtle ways. For short sessions, you might not notice. For longer, multi-step workflows -- publishing pipelines, multi-file refactors, anything with state -- the degradation compounds.

Encoding these rules as a skill means I never have to think about them. The agent consults the checklist before complex tasks and follows the terminal protocol automatically. I just do the work.

The repo: copilot-context-skills on GitHub

The previous post: I Built Reusable Marketing Skills for GitHub Copilot -- Here's How and Why

What patterns have you noticed that drain context faster than they should? I'd like to expand the skill with more real-world examples.

I Built Reusable Marketing Skills for GitHub Copilot — Here's How (and Why)

Wilco Rakhorst — Sun, 03 May 2026 08:22:49 +0000

What if your code editor could do keyword research, audit your SEO, and optimize your content for AI search engines — without leaving VS Code?

I built a set of open-source agent skills that turn GitHub Copilot into a hands-on marketing strategist. Here's what I learned, how they work, and how you can use (or build) your own.

The problem
I run a small website. Every time I wanted to write a blog post, the workflow looked like this:

Open Ahrefs/Semrush → research keywords
Open Google Docs → write the article
Open WordPress → publish and fill in SEO fields
Open ChatGPT → rewrite for social media
Repeat
Five tools. Five context switches. And every time, I found myself giving the same SEO instructions to AI assistants: "Use the keyword in the first paragraph", "Write a meta description under 155 characters", "Structure with H2/H3 headings"...

What if I could encode all that knowledge once, and have my AI assistant apply it automatically?

The solution: Copilot Skills
GitHub Copilot (in agent mode) can read SKILL.md files from your workspace. These files act as knowledge modules — they tell Copilot how to approach a domain, what rules to follow, and what frameworks to apply.

I created four skills that cover the full marketing workflow:

seo-keyword-research → Find what your audience searches for
↓
seo-strategy → Structure your site to rank
↓
geo-optimization → Get cited by AI search engines
↓
content-creator → Write content that ranks AND gets cited
What's inside a skill?
A skill is just a Markdown file with structured knowledge. Here's a simplified look at the GEO (Generative Engine Optimization) skill:

name: geo-optimization
description: "\"Optimize content for AI search engines like ChatGPT, "
Gemini, and Perplexity. Use when the user mentions 'AI visibility',

'GEO', 'AI search', or 'cited by AI'."

GEO — Generative Engine Optimization

What is GEO?

GEO = optimizing content so AI-powered search engines cite your
brand in generated answers.

GEO Scorecard (16 criteria)

Criterion	Target
Authoritative tone	Expert language, no hedging
Structured data	Schema markup present
...

Anti-patterns

Don't do this	Why
Keyword stuffing	AI recognizes and skips it
...

The description field is key — Copilot uses it to decide when to invoke the skill. The body contains the actual knowledge the AI applies.

How it works in practice
Here's what a real session looks like:

Me: "Do keyword research for a blog about home espresso machines"

Copilot (automatically invokes seo-keyword-research):

Searches the web for related keywords
Classifies intent (informational, commercial, transactional)
Analyzes SERP features
Outputs a structured keyword map with primary/secondary keywords, difficulty estimates, and content type recommendations
Me: "Now write the article and optimize it for AI search"

Copilot (invokes content-creator + geo-optimization):

Writes with proper H2/H3 structure
Includes the keyword in the first paragraph
Adds statistics with citations (GEO requirement)
Uses authoritative tone
Ends with a clear conclusion (AI search engines need this)
Generates meta title and description within character limits
Me: "Publish as draft to WordPress"

Copilot (uses REST API knowledge from seo-strategy):

Creates the post via wp-json/wp/v2/posts
Sets Yoast SEO meta fields
Outputs the draft URL
Total time: ~15 minutes. From zero to published draft with SEO metadata.

The GEO angle: why AI search changes everything
Here's something most developers don't think about: when someone asks ChatGPT "what's the best espresso machine for beginners?", the answer comes from somewhere. That somewhere could be your website — but only if your content is structured in a way AI models can parse and trust.

This is called Generative Engine Optimization (GEO). It's like SEO, but for AI search engines. The research (Aggarwal et al., 2024) shows that GEO techniques can boost visibility in AI-generated answers by up to 40%.

My geo-optimization skill includes:

A 16-criterion scorecard for AI-readiness
Writing guidelines that balance human readability and AI parseability
Anti-patterns (things that make AI skip your content)
E-E-A-T implementation (Experience, Expertise, Authoritativeness, Trust)
What I learned building these skills

Skills need evidence, not opinions AI assistants hallucinate. If your skill says "meta descriptions should be 155 characters" without a source, Copilot might second-guess it or contradict itself later.

I added a sources file with links to Moz, Ahrefs, Google Search Central, and peer-reviewed papers. This makes the skill more reliable and more trustworthy for users.

The description field is your trigger Copilot decides which skill to invoke based on the description in the YAML frontmatter. Be specific about trigger words:

description: "Use when the user mentions 'SEO', 'search engine
optimization', 'Google rankings', 'rank higher', 'meta tags'..."
The more trigger phrases you include, the more reliably it activates.

Structure > prose
Tables, bullet lists, and clear headings work better than long paragraphs. The AI parses structured content faster and applies it more consistently.
Skills should reference each other
My skills cross-link: the SEO strategy skill says "for keyword research, see seo-keyword-research". This helps Copilot chain skills together in multi-step workflows.

Installation (30 seconds)
git clone https://github.com/WilcoRakhorst/helder-ai-marketing-skills.git
That's it. Open VS Code with Copilot agent mode, and start asking marketing questions. Copilot auto-discovers the skills.

Or as a Git submodule (stays updatable):

git submodule add https://github.com/WilcoRakhorst/helder-ai-marketing-skills.git .github/skills/marketing
Build your own skills
The pattern works for any domain knowledge:

Create a SKILL.md in .github/skills/your-skill/
Add YAML frontmatter with name and description (include trigger words)
Write structured knowledge — tables, checklists, decision trees
Add references for any factual claims
Test it — ask Copilot questions in the skill's domain and see if it gets invoked
Domains that would benefit from this approach:

Accessibility (WCAG guidelines as a skill)
Security (OWASP Top 10 as actionable checklists)
API design (REST/GraphQL conventions)
Legal/compliance (GDPR, cookie consent rules)
Brand guidelines (tone of voice, terminology)
The repo
GitHub: helder-ai/marketing-skills

Licensed CC BY-NC 4.0 — free to use, adapt, and learn from.

If you find it useful: ⭐ the repo, or open a PR if you have improvements. I'd especially love contributions from SEO practitioners who want to encode their expertise.

What domain knowledge would you encode as a Copilot skill? Let me know in the comments!