alexmskills

A hook-driven coach that watches your prompts to Claude Code and nudges you toward proven prompting best practices (definition-of-done, scoped references, guardrails, verification). Ships a tiered rule catalog; rules quietly graduate once you consistently apply them so the coach fades as you improve. Beta.

Design a scalable system — architecture, data flow, APIs, schema, caching — then implement its minimal production version, applying the repo's evolving `architect` role (.claude/roles/architect.md). Invoke explicitly.

Run any registered role from the repo's evolving role repository (.claude/roles/) against a target — the generic solo dispatcher for roles that have no dedicated wrapper skill. Invoke explicitly.

Scaffold a complete, production-ready application from scratch — architecture first, then a minimal but scalable MVP — applying the repo's evolving `builder` role (.claude/roles/builder.md). Invoke explicitly.

Investigate a bug step by step, find the true root cause, and ship a robust production-ready fix, applying the repo's evolving `debugger` role (.claude/roles/debugger.md). Invoke explicitly.

Find bottlenecks and unnecessary work, then improve speed, memory, and scalability with measured, behavior-preserving changes, applying the repo's evolving `optimizer` role (.claude/roles/optimizer.md). Invoke explicitly.

Restructure code into clean architecture — separate concerns, raise modularity, reduce coupling, behavior unchanged — applying the repo's evolving `refactorer` role (.claude/roles/refactorer.md). Invoke explicitly.

Map an unfamiliar or large codebase and refactor it safely — behavior unchanged, quality raised — applying the repo's evolving `reviewer` role (.claude/roles/reviewer.md). Invoke explicitly.

Pressure-test a plan, finding, or design — steelman it, attack correctness/necessity/cost, and deliver a REFUTED / HOLDS / HOLDS-WITH-CUTS verdict — applying the repo's evolving `skeptic` role (.claude/roles/skeptic.md). Invoke explicitly.

Audit and tighten the current repository so Claude Code works faster and more accurately in it — verify the existing CLAUDE.md still matches reality, tighten the build/test/lint verification loop, add only the missing static guardrails, and reduce permission friction. Use when the user wants to "tune", "audit", "harden", or "onboard" a repo for Claude/AI agents, fix a stale or thin CLAUDE.md, or make agent runs more reliable. Works in any repo; pass "audit" to report without changing anything.

Generate a presentation-worthy screenshot deck of the current product — discovers the aspects worth showing (the CLI's `--help`, the web app's routes, the library's quickstart), captures each with the *right tool per surface* (project's existing browser driver for web — Selenium-Java if none / Playwright for Node-Python / VHS for CLI / Freeze for code snippets), and assembles a captioned, narrative-ordered deck under `presentation/` ready to walk through in a meeting, paste into slides, or send to stakeholders. Use when the user asks for "presentation screenshots", "a demo deck", "screenshots for a slide deck", "show what this does", "presentation of the product", or is preparing to demo/pitch the project. Works on CLIs, web apps, libraries, and TUIs.

Given a piece of targeted work — a problem to solve, a deliverable to improve, or an idea to develop — assemble the right panel of role-specialized agents, pick a coordination style suited to the task, and run a brainstorming loop where the panel generates, critiques, and refines until it converges on a strong result. The skill chooses the team and the management style itself based on the work; the user just supplies the work. Use this whenever the user hands over a task and wants multiple expert perspectives applied to it — when they ask to "brainstorm," "get a team on this," make something "better / more appealing / more convincing," explore options, or pressure-test an idea. Trigger even if the user only describes the work and doesn't name roles, a process, or a "panel."

Use this to take a delivery task through a task-fit roster of role subagents — composed for the work and run as a gated relay (architect -> dev -> qa -> deployer is one example lineup; the roster is dynamic), where each role runs as a subagent on its own model tier. Trigger on "run the crew on", "ship this feature", "build and test X", "take this through the cycle", or any multi-step implementation/refactor/release task that benefits from separated design, build, verify, and deploy phases. The roster is editable per task and self-evolves: roles and their model tiers are added, promoted, demoted, and graduated into each repo's CLAUDE.md as the skill learns the codebase's cycle.

Audit + refine the role files in `.claude/roles/` so role personas keep improving after the first graduation. Surfaces consolidation candidates (≥3 Learnings entries on one topic → propose merge), staleness candidates (Learnings citing files/symbols that no longer exist), Body drift (cumulative learnings contradict the Charter/Body), and solo→core graduation candidates. All proposals are user-gated — the skill never silently rewrites a role file. Use when the user says "evolve roles", "audit roles", "consolidate role learnings", "refresh roles", "what should we graduate", or "roles are getting stale". Runs proactively too — periodically when many sessions across a repo have appended to role files. Complements (doesn't replace) the SessionStart `roles-init-audit.py` hook, which is reactive and lightweight; this skill is on-demand and deeper.

Set up CLAUDE.md to maintain a living Decisions & Learnings log that the assistant updates as the project evolves. Use when initializing a CLAUDE.md, when the user asks for "learnings", "decisions log", "project memory in CLAUDE.md", "make CLAUDE.md evolve", or when a CLAUDE.md exists but has no mechanism for keeping itself current. Complements (does not replace) the built-in `init` skill — `init` bootstraps the description of the codebase; this adds the mechanism for the file to grow without bloating.

The "discover" orchestrator on the marketplace's shared role substrate — the counterpart to dev-crew (deliver) and brainstorm-panel (decide). Compose a task-fit team of coverage roles for an information space, partition it into non-overlapping angles, fan the roles out as parallel research agents under one output contract, merge their results from the agent transcripts via jq (without dumping the JSONL back into context), dedup, and adversarially verify the synthesized findings. Use when the user asks for something "comprehensive", "exhaustive", "as many as possible", "every X", a "catalog/survey/landscape of Y", or any large-scale gathering task where one agent's coverage would be insufficient and re-outputting each agent's result into a Write call would burn output tokens unnecessarily.

Drive a GitHub issue from branch to pull request — read the issue, create a feature branch, implement the change, run the project's build and tests, then commit, push, and open a PR. Language and build-tool agnostic. Use when asked to implement, fix, or resolve a GitHub issue by number.

Save a learning to project memory. Invoke automatically (without the user asking) whenever a task required more than one fix cycle to resolve — e.g. a test failed and needed a second attempt, a compile error required a correction, an API behaved unexpectedly, or an assumption proved wrong mid-task. Also invoke when the user explicitly asks to remember something. Do NOT invoke for routine single-pass work.

Coding standards, formatting, and static-analysis conventions for Maven/Java projects using spring-javaformat, Checkstyle, and PMD. Use when checking or fixing code-style violations, or when asking what the project's formatting and naming rules are.

Check JaCoCo code coverage for a Maven/Java project against a coverage gate, then drill into per-module, per-class, and per-line gaps to target tests. Use when checking coverage, finding uncovered code, or planning tests to reach a coverage threshold.

Run pre-commit quality checks for a Maven/Java project — auto-format, validate Checkstyle/PMD, and run tests before committing. Use before creating a commit, or when asked to verify the working tree is ready to commit.

Defensively scan a codebase (or a specific path) for OWASP-style vulnerabilities — injection, path traversal, unsafe reflection/deserialization, SSRF, hardcoded secrets, and XXE — and report each confirmed finding with its file:line location, severity, and concrete remediation. Use when asked to do a security audit, review code for vulnerabilities, find injection/SSRF/secret-exposure risks, or harden a project before release.