Source: This is a summary of a podcast/YouTube video featuring Ross Mike discussing AI agents, context windows, and skill-building strategies. Watch the original video
Ross Mike joins a podcast to share his hands-on philosophy for getting the most out of AI agents like Claude Code and OpenCloud. The core message: the models are already excellent — what separates great results from mediocre ones is how you structure context and build skills, not how many tools you stack on top. He argues against bloated agent.md files and downloaded skill packs, and instead advocates for iteratively teaching your agent your specific workflows from scratch.
Modern models (Opus, GPT-4/5) are genuinely capable. The quality gap between outputs isn't a model problem — it's a context problem. You can steer the same model toward quality output or "slop" depending on how well you've structured your context and instructions.
An agent's context window is built from several layers:
- System prompt (set by the model provider, e.g., Claude Code's leaked system prompt)
- agent.md / CLAUDE.md files (user-defined instructions added at every turn)
- Skills (only name + description added per turn; full content loaded on-demand)
- Tools (read, write, search, etc.)
- Codebase (the actual code acts as context)
- Conversation history
This can fill 200K+ tokens, at which point agents "compact" to save space.
95% of users don't need a large agent.md file. If your codebase uses React, the agent can see that — you don't need to tell it. Every line of agent.md costs tokens on every single turn. A 1,000-line file (~7,000 tokens) added repeatedly is wasteful and degrades performance as the context window fills.
The 5% exception: Proprietary company information or highly specific methodologies that must be referenced in every interaction.
Skills are the better alternative. A skill file has:
- A name
- A description (these two are the only things loaded into context by default)
- Full content (loaded only when the agent determines it needs that skill)
Example: A "code structure" skill at 944 tokens costs only ~53 tokens per turn until invoked — saving 94% of context overhead compared to putting it in agent.md.
Most people make the mistake of:
- Identifying a workflow → immediately creating a skill
The correct method:
- Identify the workflow
- Walk through it step-by-step with the agent (teach it what good looks like)
- Achieve a successful run
- Then tell the agent: "Review what you just did and create a skill.md file from this"
Ross used this to build a sponsor vetting workflow: he manually walked the agent through checking Twitter, YouTube, Trustpilot, and funding history — once it succeeded, he converted that session into a skill.
Skills aren't static. When the agent fails using a skill:
- Ask it why it failed — it will describe the error
- Feed the failure back, ask it to fix it
- Once fixed, tell it to update the skill file so the error doesn't recur
After 5 iterations, Ross's YouTube report generator (pulling from Notion, YouTube Analytics, Twitter, Dub, and 4 other sources) runs flawlessly for 10 minutes without intervention.
A common mistake: setting up 15 sub-agents and 30 skills immediately, before any workflows are defined. Ross's recommended progression:
- Start with one agent
- Build skills iteratively for your real workflows
- Only add sub-agents when a specific workflow justifies specialization
- His current setup: 1 main agent + 5 sub-agents (marketing, business, personal, etc.)
Skills from marketplaces or GitHub don't have the context of your successful runs — they're generic. Worse, downloading random skill files is a potential attack vector. Review them for ideas, but build your own.
- The models are already excellent — quality problems almost always trace back to context, not capability
- agent.md bloat is a real problem — every token in that file is spent on every turn, crowding out useful context and accelerating context window degradation
- Skills use progressive disclosure — only the name and description load by default; full content is fetched on-demand, making them dramatically more efficient
- Never create a skill cold — always walk the workflow with the agent first, achieve a successful run, then generate the skill from that context
- Treat errors as iteration fuel — a failure is an opportunity to identify gaps in your skill and patch them recursively
- Less is more — a lean, well-tuned agent outperforms a bloated one with 30 skills and 15 sub-agents that were never properly trained
- What you uniquely bring to agents is your workflow, taste, and strategy — models know general knowledge; skills are how you encode what makes you different
- Audit your agent.md / CLAUDE.md — strip anything the model already knows (frameworks, common patterns). Keep only truly proprietary information.
- Convert large agent.md sections into skills — anything that's workflow-specific but not needed on every turn belongs in a skill file, not the always-loaded context.
- For every new workflow: run it manually with the agent step-by-step before creating any skill file. Let the agent learn from a successful run first.
- When a skill fails: don't restart — ask the agent why it failed, have it fix the issue, then instruct it to update the skill file with the fix.
- Scale sub-agents gradually — add a sub-agent only when you have a fully-defined, working workflow that justifies the specialization.
- Start fresh templates seriously — a solid codebase template acts as rich context for coding agents, reducing the need for verbose configuration files.
- Don't install skills from marketplaces — study them for inspiration, but build your own with your actual workflow context baked in.