Claude Skills by athola

Generate program dashboards, GitHub-ready comment digests, and CSV summaries sourced from Minister's tracker data. Use when creating status reports, weekly updates, or stakeholder briefings.

Declarative release readiness checklist that mirrors GitHub checks, deployment issues, and documentation requirements. Use when preparing releases, validating deployment gates, or conducting release reviews.

Master Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Use when building async APIs, concurrent systems, or I/O-bound applications.

Create distributable Python packages with proper structure and publishing. Use for libraries, CLI tools, and code distribution.

Profile and optimize Python code using cProfile, memory profilers, and performance best practices. Use when debugging slow code, optimizing bottlenecks, or improving application performance.

Python testing with pytest, fixtures, mocking, and TDD workflows. Use when writing unit tests, setting up test suites, or implementing test-driven development.

Evaluate public API surfaces against internal guidelines and external exemplars. Use for API design review, consistency audits, and documentation governance.

Evaluate codebase architecture against ADRs, coupling rules, and team guardrails.

Systematically uncover and fix bugs using language-specific expertise and reproducible evidence. Use for deep bug hunting, defect documentation, and fix verification.

Audit Makefiles for duplication, portability, and idiomatic GNU Make usage. Use for build system reviews.

Intensive mathematical analysis for numerical stability, algorithm correctness, and alignment with authoritative standards. Use for math-heavy code changes.

Expert-level Rust audits covering ownership, concurrency, unsafe blocks, traits, and Cargo dependencies. Use for Rust-specific code review.

Evaluate and upgrade test suites with TDD/BDD rigor, coverage tracking, and quality assessment. Use for test suite audits and improvement.

Orchestrate and run appropriate pensive review skills based on codebase analysis and context. Use for intelligent review skill selection and integrated reporting.

Generate conventional commit messages from staged changes by inspecting diffs, picking the correct type/scope, and writing the final text.

Consolidates ephemeral LLM-generated markdown files into permanent documentation. Use when you have untracked report files (API_REVIEW_REPORT.md, REFACTORING_REPORT.md, etc.) that contain valuable insights but should not be committed to git.

Update documentation files based on recent changes while enforcing project writing guidelines.

Structured file enumeration and content analysis for understanding codebase structure before reviews or refactoring.

Lightweight preflight checklist for verifying repo path, staged changes, and diffs before other workflows.

Prepare a pull request by validating the workspace, running quality gates, summarizing changes, and drafting the PR template.

Scope-focused PR code review that validates against original requirements and routes out-of-scope findings to GitHub issues. Prevents overengineering by distinguishing blocking issues from backlog items.

Update and maintain tests following TDD/BDD principles with comprehensive quality assurance. Use when updating existing tests, generating new tests, or enhancing test quality across codebases.

Consolidate README content using language-aware exemplars, internal doc linkage, and reproducible evidence.

Bump project versions across configs, docs, and changelog using git-workspace-review context.

Retrospective workflow to evaluate the most recent command/session slice in the current context window and drive improvements to the skills, agents, commands, and hooks involved.

Create clear, testable specifications from natural language descriptions. Focus on what users need and why, not implementation details.

Workflow orchestrator for Spec Driven Development. Coordinates skill loading, tracks progress, and ensures consistency.

Generate dependency-ordered implementation tasks from specifications and plans. Create actionable, phased task breakdowns.

'Surfaces expert frameworks and proven methodologies before creating

TDD-style testing methodology for skills using fresh subagent instances

Architecture-aware project initialization combining online research with archetype selection. project initialization, new project, architecture decision, project setup, which architecture, choose architecture, project architecture Use when: initializing a new project and need to select an appropriate architecture based on project type, team size, domain complexity, and current best practices DO NOT use when: architecture is already decided - use project-init instead. DO NOT use when: explo...

Generate language-specific Makefiles with common development targets for testing, linting, and automation. Use when: initializing projects, setting up development workflow, standardizing commands. Do not use when: Makefile already exists and is current.

Configure three-layer pre-commit quality system with linting, type checking, and testing hooks. Use when: setting up quality gates, configuring pre-commit, establishing code quality standards. Do not use when: pre-commit already configured optimally.

Guide project ideation through Socratic questioning and constraint analysis to create actionable project briefs. Use when: starting projects, exploring problem spaces, comparing approaches, validating feasibility. Do not use when: requirements already clear and specification exists.

Execute implementation plans systematically with checkpoint validation, progress tracking, and continuous quality gates. Use when: implementing tasks, executing plans, tracking progress, validating checkpoints. Do not use when: no implementation plan exists or still in planning phase.

Interactive project initialization with git setup, workflows, hooks, and build configuration. project setup, initialization, scaffold, bootstrap, new project Use when: starting new projects or initializing repositories

Transform specifications into structured implementation plans with architecture design and dependency-ordered task breakdown. Use when: converting specs to plans, designing architecture, breaking down tasks, estimating effort. Do not use when: no specification exists yet or still brainstorming approaches.

Transform project briefs into detailed, testable specifications using spec-driven development methodology. Use when: translating requirements, defining acceptance criteria, creating technical specs, before implementation. Do not use when: already have detailed specification or still exploring problem space.

Inline reversibility assessment for embedded War Room escalation from other commands. Use when: called from commands at decision points, determining if escalation needed. Do not use when: standalone strategic decisions, simple questions.

Multi-LLM deliberation framework for strategic decisions through expert pressure-testing and consensus building. Use when: critical decisions, irreversible changes, architecture choices, conflicting approaches, high stakes. Do not use when: decision is trivial, easily reversible, or already made.

Configure GitHub Actions CI/CD workflows for automated testing, linting, and deployment. Use when: setting up CI/CD, configuring GitHub Actions, automating quality checks. Do not use when: CI/CD already configured or using different platform.

'Detect codebase bloat through progressive analysis: dead code, duplication,

'Automatic context management with graceful handoff to continuation subagent.

'Provides guidance on fundamental software design principles to reduce

'Guidance on when to ask clarifying questions vs proceed with standard

'hype, and unnecessary framing. Includes termination and directness guidelines.

'balancing accuracy with token efficiency. Use when: source, cite, reference,

This skill provides the catalog and guides installation. Use when looking

Create hookify rules - markdown-based behavioral rules preventing unwanted actions. create hookify rule, behavioral rule, prevent behavior, block command Use when: preventing dangerous commands, blocking debug commits, enforcing conventions DO NOT use when: hook scope (abstract:hook-scope-guide), SDK hooks (abstract:hook-authoring), evaluating hooks (abstract:hooks-eval)

Feature review and prioritization with RICE/WSJF/Kano scoring. Creates GitHub issues for suggestions. feature review, prioritization, RICE, WSJF, roadmap, backlog Use when: reviewing features or suggesting new features DO NOT use when: evaluating single feature scope - use scope-guard.