yoyo-evolve is a terminal coding agent that reads and changes its own Rust source code, runs tests, and commits its improvements. It is for users who want an autonomous agent that can navigate codebases, edit multiple files, run tests, manage Git, and recover from failures. The catalogue entries are skills for working with this coding agent.
Getting it into your agent
One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.
npx skills add yologdev/yoyo-evolve --skill explore-codebasegit clone --depth 1 https://github.com/yologdev/yoyo-evolveWrote this? Show the measurements
A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.
[](https://agentmods.dev/skills/yologdev/yoyo-evolve/explore-codebase)<a href="https://agentmods.dev/skills/yologdev/yoyo-evolve/explore-codebase"><img src="https://agentmods.dev/badge/skills/yologdev/yoyo-evolve/explore-codebase/github.svg" alt="Measured on agentmods" height="20"></a>Or the 80×15 button, for a site that already has a row of RSS and ATOM ones. Only the verdict fits; the numbers stay here.
<a href="https://agentmods.dev/skills/yologdev/yoyo-evolve/explore-codebase"><img src="https://agentmods.dev/badge/skills/yologdev/yoyo-evolve/explore-codebase.svg" alt="Reviewed on agentmods" width="80" height="20"></a>- NVIDIA SkillSpector pass
What it costs to keep this loaded
Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.
| Model | Per session | Once invoked |
|---|---|---|
| Fable 5.1 | $0.00035 | $0.02620 |
| Opus 5.5 | $0.00014 | $0.01048 |
| Sonnet 5.5 | $0.00007 | $0.00524 |
| Haiku 4.5 | $0.00003 | $0.00262 |
Grade A, and why
explore-codebase scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 1mo ago.
A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.
Nothing flagged
None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.
How it starts
The opening of the file, as written. The whole thing — 209 lines — stays where its author put it; the contents beside it link to each section on GitHub.
Explore Codebase
You are building a mental map of an unfamiliar or large codebase region. The goal is structural comprehension — understanding what the code does, how it's organized, and what the key entry points and invariants are — without loading everything into your main context window.
This skill exists because codebases are too large to read in one prompt. The pattern (Recursive Language Model — see the RLM substrate section in CLAUDE.md) is: keep your root context small, dispatch sub-agents to read individual files or modules, and have each sub-agent return a structured summary. Synthesize the summaries into a coherent map.
This skill covers any codebase the agent encounters — forks, dependencies, unfamiliar regions, user projects. For analyzing yoyo's own source to find bugs and gaps, use self-assess instead.
When to use
Trigger this skill when ANY of these hold:
- A planned task touches >5 files you haven't recently worked on
- A community issue references a feature or module you don't have a mental map for
- You're investigating a bug whose surface spans multiple modules you haven't read recently
- A new dependency is being introduced and you want to know its public API + key invariants before integrating
- A user explicitly asks you to explore, understand, or map a codebase
/addbrought in a large project and you need structural context before acting- You're working in a fork and need to understand what the fork changed relative to upstream
When NOT to use
- Small known regions. A single file ≤300 lines, or a function you wrote yesterday — just read it directly. Sub-agent overhead exceeds the savings.
- Precise edits across files. Refactoring needs mutual context (seeing all pieces at once), not summaries. Summaries lose the fidelity you need for surgical edits.
- Sequential workflows with strong mutual context. When each step depends on the full output of the previous step, fan-out doesn't help — you need serial reading.
- The region is already known. If you or the user can name the exact module and its API from memory, direct read is faster. Don't explore what you already understand.
- You're inside a sub-agent at depth 3. Stop. Return what you have. Do not dispatch further.
What this file has done since we first saw it
Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.
- 1mo ago First seen · 209 lines · 35 tokens per session scan A 08ce6a026c6c
explore-codebase is a skill published in the GitHub repository yologdev/yoyo-evolve (1,915 stars, last pushed today), licensed MIT. It adds 35 tokens to every session and 2,620 once invoked, about $0.0001 per session on Opus 5.5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-30.
Other skills, from other repositories
tldr-code
Token-efficient code analysis via 5-layer stack (AST, Call Graph, CFG, DFG, PDG). 95% token savings.
debug-optimize-lcp
Guides debugging and optimizing Largest Contentful Paint (LCP) using Chrome DevTools MCP tools. Use this skill whenever the user asks about LCP performance, slow page loads, Core Web Vitals optimization, or wants to understand why their page's main content takes too long to appear. Also use when the user mentions…
systematic-debugging
Use when debugging a failing test, build error, or runtime issue that isn't immediately obvious. Guides a 4-phase root cause analysis instead of random fix attempts.
log-error-digest
Analyze log files to troubleshoot errors, identify peak error periods, and produce error clustering, frequency statistics, and time distribution reports. Supports JSON, syslog, and Nginx formats with automatic detection. Use when a user uploads a .log file and asks to analyze errors, find patterns, debug issues, or…
deck-retro
Run a fully local agent-deck retrospective over the user's own transcripts, Recall index and logs. Use when a user wants to find recurring failures or take their own finding from investigation through synthetic reproduction, a user-filed issue, a test-first fix and contributor PR handoff. Also use for weekly usage…
incident-response-incident-response
Coordinate production incident triage, mitigation, investigation, recovery, and follow-up. Use when responding to outages or other incidents that require structured operational coordination.