A SNOWBROS product · v1 · Open sourceOne task.
Only the right experts.
Snowbros Mentor is an engineering intelligence system for Claude Code. Like a senior engineering manager, it reads a task and pulls in only the specialists it needs — then either teaches it or builds it, running the reviews that actually apply.
10 capabilities · 12 references · 2 modes · MIT
Router · example
Pulled
Skipped
// two modes
The same experts can teach it, or build it.
Train toward elite judgment.
From first principles, not recipes. Full lessons with mental models, exercises, review gates, and a leveled roadmap from Foundations to Principal — verified by retrieval, not assertion.
- Why-it-matters → first principles → practice → anti-patterns
- Easy · medium · hard · real-world exercises, solutions withheld
- Interview-style questions that challenge assumptions
Act as an autonomous Staff engineer.
Classify the task, route to only the needed capabilities, produce the solution, then run only the review gates the change implicates — and say which ones and why.
- Complexity tiers bound how much gets read
- Code · security · architecture · design · AI review gates
- Incremental docs and clean checkpoints on long work
// ten capabilities
Merged, not fragmented. One capability, one file.
Software Core
Code quality, naming & API design, testing, refactoring, debugging method, concurrency, performance engineering, error handling, git, dependencies.
Backend & Data
HTTP, API design, data modeling, relational depth, async & queues, multi-tenancy, backend reliability patterns, pipelines.
Frontend & Web
The platform, rendering pipeline, state taxonomy, server-state, SSR/CSR, Core Web Vitals, CSS architecture, build tooling, resilience.
Architecture
Coupling & cohesion, SOLID, DDD, monolith vs microservices, distributed systems, caching, event-driven, CQRS, scaling, high availability.
Security
Threat modeling, secure-design principles, root-cause vuln families, authn/authz, API/frontend/DB/infra security, DevSecOps, supply chain, detection.
Design
Perception & UX psychology, typography, color, layout, components, design systems, motion, accessibility, product thinking, seven-lens critique.
AI Engineering
LLM fundamentals, prompting, tool calling, embeddings & RAG, agents, memory, MCP, evaluation, safety, serving/cost/latency, AI UX.
DevOps & SRE
CI/CD, release engineering, containers & K8s, IaC, cloud, observability, SLOs & error budgets, incidents, postmortems, platform & DX.
Leadership & Career
Communication, technical writing & RFCs, code-review craft, decision-making, influence, estimation, mentorship, the ladder, interviewing.
Learning System
Five competence levels, portfolio project ladder, assessment gates, and the teaching mechanics that turn lessons into an education.
// how it works
Decide what to read before reading it.
Understand
restate the ask
Classify
tiny → massive
Route
minimum capabilities
Compose
load only needed refs
Produce
solution or lesson
Review
only implicated gates
Document
incremental patch
Checkpoint
if context runs low
Progressive disclosure is the token engine — unopened references cost nothing, so correct routing is the optimization. Read the orchestration engine →
// routing
It never invokes every capability.
| Task | Pulled | Skipped |
|---|---|---|
| Build a login page | Design · Frontend · Security (authn) | K8s · DB scaling · AI |
| Review my authentication | Security · Backend · Architecture | Design · Frontend |
| Optimize my dashboard | Frontend (perf) · Design (UX) · Backend | Security infra · AI |
| Add a RAG feature | AI · Backend · Security (injection) | Design · DevOps |
| Design the order system | Architecture · Backend · Security | Frontend · Design |
| Teach me caching | Architecture (+ Backend / DevOps links) | Design · AI |
// review gates
Only the reviews the change implicates.
Code review
Three-pass procedure, issues named and located, 1–10 category scores with honest calibration, then the Staff rewrite.
Design critique
Seven lenses — heuristics, cognitive load, accessibility, feasibility, business impact, craft, competitive benchmarking.
Architecture review
Forces → alternatives → tradeoffs → failure modes → when-not-to-use, at the altitude of a real design review.
Security review
A repeatable framework: trust boundaries → input → authz → secrets → dependencies → defense in depth.
Operational readiness
Deploy, rollback, observability, SLOs, capacity, failure, incident readiness — before a service ships.
AI feature readiness
Evals before features, grounding, injection defense, cost & latency budgets, agent guardrails.
// honest by design
It does what a skill really can — and refuses to fake the rest.
No fake token meter
A skill can't read its own remaining context. Instead of pretending, it classifies complexity up front to bound how much it reads — proactive, not imaginary.
Checkpoints, not degraded answers
On long work it writes state and a continuation plan to disk so a fresh context resumes cleanly — rather than producing a worse answer to beat a limit.
Reuse over reinvention
Cross-session memory and codebase knowledge graphs already exist in the harness and the graphify skill. Mentor points at them instead of building parallel, rotting copies.
Merged, not fragmented
One capability equals one file. All of design is one reference, all of security is one — the registry is the router, and routing to the minimum is the token engine.
// install
Clone it into your skills folder. Then just ask.
Global — all projects
git clone https://github.com/snowbros-labs/mentor-skill.git ~/.claude/skills/mentorThen, in Claude Code
/mentor review my authenticationIt triggers only when you ask for it, so quick one-off questions stay quick. Read the README →
// at a glance
Open source, and small on purpose.
0
Capabilities
0
Reference files
0
Modes
MIT
License
// faq
Questions, answered.
What is it, exactly?
A skill for Claude Code — a folder of Markdown the assistant loads on request. It adds an orchestration layer that composes ten specialist engineering capabilities and runs the right review gates, in either a teaching or a building mode.
Does it auto-run on every message?
No. It triggers only when you ask — "/mentor", "teach me X", or "use mentor to build/review Z". It produces structured lessons and reviews, so it stays out of the way of quick one-off questions.
How does it save tokens?
Progressive disclosure. Unopened capability files cost nothing, so correct routing is the optimization. Complexity tiers cap how many files get read, and it never reloads the whole project when one module changed.
Is it tied to a specific model or stack?
The curriculum is stack-agnostic and principle-first. It's built for Claude Code but the references are plain Markdown you can read anywhere. MIT licensed.
// open source · MIT
A Staff engineer and a whole curriculum, in one skill.
Clone it, read it, and put it to work — then tell us where it’s wrong.