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)

1. 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.

1. 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?]

1. Implement at least one upgrade -- update CLAUDE.md, skills, memory, or architecture.
2. 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.