System Check -- Self-Evolution Audit

The most important skill. This is how the entire learning system gets smarter.

Trigger

• /system-check
• During Friday reflections
• When coaching feels off or exercises feel too easy/hard

Execution

1. Read current state:
   • CLAUDE.md (coaching rules being followed?)
   • ROADMAP.md (pace right? too slow? too fast?)
   • PROGRESS.md last 7 entries (trajectory)
   • Memory files (patterns observed)

2. Evaluate five dimensions:

   a. Coaching effectiveness:

   • Which questions revealed real depth this week?
   • Which coaching techniques produced breakthroughs?
   • What fell flat? What should change?
   • Is the student's understanding deepening or plateauing? Evidence?

   b. Curriculum vs. market:

   • Run /trends for latest industry data
   • Does current topic match what companies hire for?
   • Should any content be added/removed/reordered?
   • Is the pace producing mastery or just exposure?

   c. Skill quality audit:

   • Which skills were used this week? Which weren't?
   • Are skill outputs actually helpful or just noise?
   • Any skills need updating based on new patterns learned?
   • Any new skills needed that don't exist yet?

   d. Knowledge retention (cross-reference /review-deck):

   • What's the spaced review hit rate?
   • Which categories have struggling cards?
   • Is knowledge compounding or leaking?

   e. System architecture:

   • CLAUDE.md under 60 lines? (official best practice)
   • .claude/rules/ still needed or redundant with native Claude behavior?
   • Memory growing usefully or accumulating noise?
   • New Claude Code capabilities to adopt? (check release notes)
   • Community skills/plugins worth integrating?

   f. Memory Health Audit (CRITICAL): Memory is the foundation of the coaching relationship. Without it, Claude cannot help the student.

   • Completeness check: Does memory contain the student's full profile, all feedback, all planning decisions?
   • Accuracy check: Read each memory file and verify against current project state. Stale memories = outdated advice.
   • SessionStart hook test: Run .claude/scripts/session-memory.sh and verify it outputs valid JSON with all critical context.
   • Coverage check: Were there decisions or corrections in recent sessions that should have been saved but weren't?
   • MEMORY.md index check: Is the index up to date? Are all memory files listed? Are any orphaned?
   • Size check: MEMORY.md must stay under 200 lines. Individual memory files should be concise, not bloated.
   • Injection check: Is the SessionStart hook injecting: user profile, key feedback, topic status, recent progress, git state, session rules?
   • Action: If any memory is stale, update or remove it. If any decision is missing, save it now.

   g. Architecture Currency Audit (CRITICAL): Practices that are best-practice today become bottlenecks as models improve. Ask: "If I set up this project from scratch today with the latest Claude Code, what would I do differently?"

   • CLAUDE.md weight check: Is each rule adding value or noise? If Claude follows it without being told, remove it.
   • Rules relevance: Are .claude/rules/ files still needed? Grep Claude Code changelog for capability improvements that obsolete rules.
   • Hooks necessity: Are hooks enforcing things Claude now does automatically? Remove friction that's no longer needed.
   • Skill architecture: Are skills using the latest frontmatter fields? New Claude Code versions add capabilities -- adopt them.
   • Feature adoption: Search changelog for new features replacing existing workarounds. If Claude adds native support for something we built manually, our manual version becomes debt.
   • Subagent model check: Are agents using optimal models? Update as faster/better models release.
   • Memory hook check: Is session-memory.sh still the best approach? Check for new Claude Code memory features that could replace it.

   h. Industry Technique Adoption (CRITICAL): The system must stay current with how expert AI practitioners work, not just what they build.

   • Search: "Claude Code new features 2026", "Claude Code best practices", "Claude Code skills trending" -- what's changed since last check?
   • Practitioner patterns: Are there new workflows (Shrivu, Osmani, Karpathy, or others) that should inform how sessions work?
   • Skill ecosystem: Search awesome-claude-skills repos (hesreallyhim/awesome-claude-code, rohitg00/awesome-claude-code-toolkit, travisvn/awesome-claude-skills). Any community skills worth adopting or learning from?
   • Student evidence audit: Run python scripts/aggregate_evidence.py --all. Are there exercises where 3+ students recorded evidence? If yes, update EXERCISE-EVIDENCE.md hints with REAL data (replace projections with actuals).
   • Career path alignment: Check market salaries and role titles. Update ROADMAP career path callouts if numbers shifted.
   • TDD evolution: Is Red-Green-Refactor still the industry standard, or has a better testing pattern emerged?
   • Self-healing: If any part of this project is broken, unused, or outdated — fix it during this check. Don't report it. Fix it.
   • Contracts check: Are all contracts (TDD, standards, session flow) being followed? If not, why? Adjust the contract or enforce it.
3. Output report:

   SYSTEM CHECK -- {date}
   
   Health: [GREEN/YELLOW/RED]
   
   Working well:
   - [specific observation with evidence]
   
   Needs adjustment:
   - [specific recommendation with action item]
   
   Curriculum alignment: [current vs market]
   
   System upgrades to implement:
   - [specific change to make NOW]
   
   Evolution metric: [how is the system different from last check?]

4. Implement at least one upgrade -- update CLAUDE.md, skills, memory, or architecture.
5. Persist insights to memory.

Rules

• Be honest about failures. "This skill isn't helping" is valid.
• Every check produces at least one concrete improvement. No check is just a report.
• The system should be measurably better after every system-check.
• Compare the student's trajectory to market requirements, not just internal progress.
• This skill can modify any file in the project -- it's the system's self-improvement mechanism.