m2ai-skills-pack

Audit your Claude Code skills directory, CLAUDE.md, and recent session patterns to surface candidates for new skills -- gaps, redundancies, and formalization opportunities -- and to catch skill hygiene failures: runtime artifacts (venv, __pycache__, node_modules) living inside a skill directory, and absolute paths or identity leaking out of tracked files.

Fetch curated, versioned API documentation through the `chub` CLI before writing code against an external API or SDK, so calls are checked against real docs instead of recalled from memory. Use before implementing anything that calls an external API, when unsure of the correct parameters, methods, or patterns, when a model name or endpoint needs verifying, or when the user asks how to use a specific service's API.

Scan a codebase for LLM model usage and recommend tier, task-fit, and cost optimizations. Works on any project using Anthropic, Google, OpenAI, or open-source models. Use to check whether each task is running on the right model tier, when a new model generation ships and you want to see if you can tier down, when you suspect you are overspending on tokens for simple tasks, or for a periodic model hygiene review.

Evaluate an agent codebase against 12 infrastructure primitives (permission model, token budget, crash recovery, tool assembly, streaming events, state machine, provenance, stop reasons, boot sequence, verification harness, memory decay, health checks) and return a severity-ranked gap analysis with prioritized upgrade path. Use when auditing agent architecture, reviewing agent readiness, or planning what infrastructure to build next.

Build a personal multi-agent AI command center using Claude Code as the immutable foundation with independently swappable specialized layers — Agent SDK bridge, voice interface (Gemini Live + Pipecat), cross-agent hive mind, self-managing memory with decay/promotion, and a mission control dashboard. Use when designing a personal AI stack, replacing an agent framework, building a multi-agent system, or asking "how do I build my own agent platform".

Generate or lint an AGENTS.md file from repository analysis. Discovers build commands, test commands, environment variables, architecture patterns, and coding conventions, then produces a comprehensive AGENTS.md that tells AI coding agents how to work in the repo. Use when the user says "generate agents.md", "create agents.md", "lint agents.md", "agents file", "agent instructions", or wants to create standardized agent onboarding docs for a repository.

Scores any agent definition or skill manifest against the four consumer-AI breakthrough problems (context, reliability, permission, judgment) plus a reactive-vs-anticipatory axis. Outputs a heatmap and ranked vulnerability list.

Score an agent system design against the Bitter Lesson principle — how much "how" is encoded vs "what", how much bets on model improvement vs locks in current limitations. Flags procedural lock-in, hardcoded orchestration, and domain hacks. Produces a simplification roadmap. Use when designing new agent systems, reviewing agent architecture, or deciding what to simplify. Trigger on "bitter lesson", "score architecture", "agent complexity audit", "simplification roadmap", "how vs what ratio", "are we fighting the model".

Takes a workflow that scored BUILD from workflow-fit-scorer and emits a deployment-ready build spec — trigger, I/O contract, tool connectors, success criteria, escalation conditions, and quality-check rubric. Output is platform-agnostic with per-platform variant notes.

Classify a problem into one of four agent architectures: coding harness, dark factory, auto research, or orchestration framework. Implements the "one-question test" diagnostic from Nate Kadlac's agent taxonomy. Use when starting a new agent project, evaluating a build approach, or when someone says "what kind of agent should I build?", "classify this", or "/classify-agent".

Interviews the user to design and build a personalized Claude Code memory system — choosing which building blocks (decay, promotion, multi-signal retrieval, salience, compaction) to include, then wiring the result into CLAUDE.md, hooks, or agent-scoped memory. Use when a user wants to build, redesign, or consolidate their Claude Code memory layer. Trigger phrases: "build my memory system", "design memory for Claude Code", "memory architect", "7 levels of memory", "personalize my CLAUDE.md memory", "memory fingerprint".

Interview-driven skill that designs a custom Claude Code memory system tailored to how the user actually works. Clones open-source memory repos, audits their patterns, then builds a personal memory spec using building blocks — decay, promotion, multi-signal retrieval, salience, disclosure, compaction — deployed via CLAUDE.md entries, hooks, or agent-scoped files. Trigger phrases: "build my memory system", "design my CLAUDE.md memory", "memory architect", "personal memory spec", "I keep repeating context to Claude".

Restructure a bloated CLAUDE.md into a lean router that delegates to compartmentalized .claude/rules/ files. Use when CLAUDE.md exceeds ~80 lines, when adding a new domain of instructions, or when the user says "clean up my CLAUDE.md", "my CLAUDE.md is too long", or "organize my rules".

Build orchestrator skills that chain multiple existing skills in sequence using context:fork, passing output between stages for a unified result. Use when the user says "chain skills", "combine skills", "orchestrator skill", "compound skill", "run skills in sequence", "skill pipeline", or wants to create a single command that runs multiple skills end-to-end.

Use when creating or modifying skills that do heavy research, search, or multi-tool work. Adds context:fork to isolate skill execution in a separate context window, keeping the main session clean. Trigger on "keep context clean", "skill is bloating my context", "run this in a separate window", or when building any research/search skill.

Reference for Claude Code context management. Use /by-the-way for side questions, /fork for path exploration, and context:fork in skills for isolated execution. Trigger on "context is getting large", "session feels slow", "Claude forgot what we were doing", "how do I manage context".

Score whether a set of coding tasks are properly decomposed on boundaries of isolation. Detects conflicts where parallel agents would touch the same files, share state, or have ordering dependencies. Use before launching parallel agent workers, when planning task breakdown for yce-harness or similar, or when someone says "will these tasks conflict?", "score my decomposition", or "/decomposition-scorer".

Generate a pre-flight delegation spec for any agent task -- context packages for memory-weak tools, review gates for opacity-prone tools, compounding checkpoints for stateless tools. The "test suite before the agent runs the work." Use when handing off a task to an agent, preparing a workflow for autonomous execution, or writing deployment specs for client agent systems.

Generate structured delegation briefs for Anthropic Dispatch or any autonomous agent handoff with objective, success criteria, tools needed, verification, and escalation conditions

Invoke Claude Code's dynamic workflow orchestration to coordinate teams of 10–50+ agents for large-scale, comprehensive tasks requiring parallel analysis and cross-validation. Trigger phrases: "build a workflow", "dynamic workflow", "/workflows", "spin up agents for", "comprehensive audit across", "workflow that reads every".

Takes a user's described operating rhythms (from structured elicitation, manual input, or existing CLAUDE.md) and generates a HEARTBEAT.md checklist plus cron schedule entries that map to their actual daily/weekly/monthly patterns. Use when the user says "generate heartbeat", "build my schedule", "create cron from rhythms", "heartbeat.md", "schedule my agent", or when setting up recurring tasks for a the agent platform agent.

Design a shared context store for a multi-agent team -- write policies, decay rules, pinning, and consolidation schedules -- so specialized agents can delegate to each other without losing state. Use when building a multi-agent system where agents need to share memory, designing memory decay and consolidation for an agent team, or wiring a routing layer over a group of specialized agents.

Refactor any reactive slash-command skill or repeating manual workflow into an anticipatory one that fires automatically when the right condition is met. Produces a settings.json hook (PreToolUse, PostToolUse, Stop, or SessionStart) or cron trigger alongside any changes to the skill itself. Use when saying "make this anticipatory", "convert this to a hook", "make it fire automatically", "this skill never fires because I forget it", "add a trigger to this skill", or wanting to turn a reactive tool into a proactive one.

Design a personalized Claude Code memory system by cloning existing open-source memory frameworks, auditing them with Claude Code, and cherry-picking the patterns that fit your workflow. Produces a lightweight memory spec with salience rules, decay/promotion schedules, and multi-signal retrieval, then wires the system via CLAUDE.md, hooks, or agent-scoped memory. Use when saying "design my memory system", "build my memory", "personalize my CLAUDE.md memory", "memory architect", or "memory fingerprint".

Build a personalized Claude Code memory system by auditing open-source memory repos, cherry-picking patterns that match your workflow, and assembling them into a coherent design. Use when setting up memory for the first time, redesigning an existing memory system, or evaluating new memory patterns from the OSS ecosystem.

An escalating ladder of copy-paste delegation-prompt patterns, extracted from prompts a frontier model wrote for itself when orchestrating subagents. Use this skill whenever the user asks for "prompt goodies", wants to write or improve a prompt that delegates work (to a subagent, an agent team, a worker, a contractor-style task, a CMD mission, or any AI doing a job unsupervised), asks "how do I write better agent prompts", complains that an agent ignored instructions / touched the wrong files / claimed success without proof, or wants prompt patterns to share with a community. Also use it to upgrade a specific delegation prompt the user pastes in, even if they never say the word "prompt".

Define and document a complete scheduled-agent contract for any recurring automated task. Produces a standardized harness spec covering trigger config, memory folder, input contract, output destination, and failure alerts — ready to wire into Claude Code or any agent runner.

Audit a multi-agent system for distributed sensemaking anti-patterns and recommend where to concentrate interpretation into a single agent, reducing conflicting signals and improving decision quality.

Score an agent system or knowledge base against five principles that determine whether a world model compounds value or silently rots — signal fidelity, earned structure, outcome encoding, organizational resistance, and accumulated reality. Complementary to bitter-lesson-scorecard (architecture simplicity) — this measures knowledge/decision quality.

Interactive diagnostic that maps an organization to a world model paradigm (vector DB, structured ontology, or signal-driven) and recommends a starting sequence for implementation. Use when assessing organizational AI readiness, choosing a knowledge architecture, or starting a consulting engagement.

Run an After-Action Review on an agent dispatch run, build execution, or multi-step orchestrated operation. Gathers forensics across the orchestrator DB, A2A endpoints, pm2 logs, git history, and queue files; classifies failure modes; captures benchmarks; produces a structured AAR. Use when the user says "aar", "after action review", "let's review what happened", "review this run", or after any dispatch that produced mixed results worth learning from.

Structured post-mortem for the failure mode where an agent executed the correct mechanical action but produced the wrong outcome — the action succeeded, the goal failed. Walks through what semantic context was missing, where to add it, and how to prevent recurrence. Use when an agent did exactly what it was told but the result was wrong, or the user says "/action-outcome-postmortem", "right action wrong result", "agent succeeded but outcome was bad", "mechanical success semantic failure".

Evaluate an existing agent setup (CLAUDE.md, SOUL.md, memory files, cron config, agent.yaml) and score it on operational completeness -- flagging missing decision frameworks, vague delegation instructions, absent escalation rules, and gaps in rhythm/schedule coverage. Use when the user says "cold start diagnostic", "check agent config", "agent health score", "is my agent configured properly", "audit agent setup", or before deploying a new agent persona.

Document and implement the pattern for capturing user corrections to agent output as structured events (user_correction_submitted). Use when building any agent-facing UI, CLI, or chat interface where you want corrections to flow into an evaluation or feedback pipeline rather than being silently discarded.

Run a comprehensive health check on all connected services, API credentials, MCP servers, tools, and external dependencies. Validates that everything the agent needs is reachable and authenticated before the user hits a failure. Use as a startup diagnostic or on-demand when things feel broken.

Audit an agent's execution environment for cold-start patterns, missing warm caches, stale dependencies, and session persistence gaps. Scores against best practices from OpenAI Hosted Shell and METR research showing unoptimized environments negate AI productivity gains. Use when the user says "optimize agent environment", "cold start audit", "agent environment check", "why is my agent slow to start", "warm cache audit", "session persistence check", or wants to speed up agent execution by fixing the environment layer.

Reference skill containing the canonical 10-event agent analytics schema. Defines event shapes (agent_run_started, task_completed, user_correction_submitted, approval_granted, approval_denied, tool_call_failed, memory_miss, run_completed, run_failed, run_aborted) with a shared agent_run_id field that joins every event for a run. Use when wiring observability into an agent pipeline, designing a logging sink, or asking "what events should my agent emit?"

Run a structured standup across a multi-agent team. Each agent reports status (what completed since last standup), blockers, and next planned action. Produces a shared war-room log with cross-agent dependencies and escalations surfaced. Use when asking for a "standup", "team status check", "/standup", "war room update", "what are all my agents doing?", or "agent status report".

Analyze the gap between an agent's self-reported completion rate and the actual acceptance rate (tasks the user or downstream validator kept without correction). Produces a 2x2 quadrant — Trusted, Overconfident, Conservative, Failing — for each workflow type. Use when the user says "completion rate", "acceptance rate", "how trusted is my agent", "agent done vs actually accepted", "completion-vs-acceptance", or wants to understand which agent workflows have earned autonomy.

Strict 4-gate diagnostic protocol for bugs, failures, and broken pipelines. Forces stating the error, gathering logs/env/recent-changes, listing 3 ranked hypotheses, and getting explicit user approval BEFORE any code edit. Use when the user reports a bug, something is broken, a test is failing, a service is down, or says "diagnose X", "what's wrong with X", "why is X failing", "/diagnose".