athola

Enforces validation and evidence before claiming work complete. Use before declaring implementation done, creating a PR, or submitting deliverables for review.

Selects and routes to the right architecture paradigm. Use when choosing patterns for a new system or comparing trade-offs before making architecture decisions.

Selects architecture paradigm via research before scaffolding. Use when architecture is undecided and the choice needs justification and documentation.

Configures pre-commit hooks for linting, type checking, formatting, and testing. Use when setting up a new project or adding quality gates to an existing one.

Detects git forge (GitHub/GitLab/Bitbucket) and maps CLI commands cross-platform. Use when writing skills that must run on any git hosting provider.

Guides project ideation via Socratic questioning to produce a validated brief. Use before specification when requirements are unclear.

Executes implementation plans with progress tracking, checkpoint validation, and quality gates. Use after planning is complete and tasks are ready to implement.

Converts a specification into a phased, dependency-ordered implementation plan. Use after specification is complete and before execution begins.

Convenes a multi-LLM expert panel to pressure-test hard-to-reverse decisions. Use when reversibility score is low and adversarial review is warranted.

Improves code quality across duplication, efficiency, and architectural fit. Use when code passes tests but quality is poor or before a major release.

Traces execution paths through the code graph with criticality scoring and Mermaid charts. Use when understanding how a function propagates through the system.

Coordinates Claude agent teams via filesystem protocol. Use when orchestrating parallel agents with task dependencies. Do not use for single-agent tasks.

Delegates tasks to Gemini or Qwen with quota tracking and error handling. Use when tasks exceed context window or need cheaper processing.

Applies NIST/CWE security hardening to Python and Rust code. Use when auditing code for vulnerabilities or proposing concrete security remediations.

Detailed development workflow with modular patterns for git, review, testing, and deployment.

Guide creating Claude Code hooks with security-first design. Use for validation and enforcement.

Select hook scope (plugin, project, global) by audience. Use when authoring a hook.

Analyze and improve the improvement process. Use for detecting regressions and meta-optimization.

Detects workflow failures and inefficient patterns then files GitHub issues. Use when a workflow step repeatedly fails or produces inconsistent output.

Inverts burden of proof for code additions. Use when reviewing PRs, planning refactors, or running unbloat to challenge every addition's necessity.

Converts documents and URLs to markdown via tiered fallback (MCP markitdown, native tools, user notice). Use when a skill must ingest PDF, DOCX, or URL content.

Provides weighted scoring, rubrics, and decision-threshold patterns. Use when designing quality gates, evaluation systems, or decision frameworks.

Assess whether to escalate models. Use when evaluating reasoning depth.

Detect friction signals; graduate patterns into rules. Use for session retrospectives.

Evaluate hook security, performance, and SDK compliance. Use for audits.

Surface expert frameworks. Use when creating or evaluating skills, hooks, or agents.

Build composable skill modules with hub-and-spoke loading. Use when token budget is tight.

Review plugin quality with tiered checks and dependency scoping. Use for PR and pre-release audits.

Guide creating Claude Code skills with TDD and persuasion principles. Use for new skill development.

Audit Skill() refs; detect hubs, isolates, and dangling targets. Use when auditing skills.

Applies client-server architecture for web/mobile apps. Use when designing systems with centralized backend services, trust boundaries, or offline-first sync.

Applies CQRS and Event Sourcing for read/write separation and audit trails. Use when designing systems with complex domain logic or full state-change history.

Browse hookify rule catalog. Use when installing pre-built rules or browsing categories. Do not use when writing custom rules; use hookify:writing-rules.

Evaluate Claude Code rules in .claude/rules/. Use for frontmatter, globs, and quality audits.

Provide reusable patterns for validation, error handling, scaffolding. Use for skill consistency.

Evaluate Claude skill quality through auditing. Use when reviewing or auditing skills.

Applies Functional Core, Imperative Shell to isolate logic from side effects. Use when business logic is entangled with I/O or unit tests are slow and brittle.

Applies layered n-tier architecture with enforced boundaries. Use when designing moderate systems needing clear presentation, domain, and persistence layers.

Applies microkernel architecture with minimal core and plugin extensibility. Use when building platforms where third parties extend core functionality.

Applies microservices for independent deployment and per-service scaling. Use when teams need autonomous release cycles with distinct capability scaling needs.

Applies event-driven async messaging to decouple producers and consumers. Use when designing real-time or multi-subscriber systems needing loose coupling.

Applies modular monolith with enforced internal boundaries. Use when teams want service-level autonomy without distributed system overhead.

Applies pipes-and-filters for sequential data transformations. Use when data flows through discrete stages like ETL, streaming analytics, or CI/CD pipelines.

Applies serverless FaaS patterns for event-driven workloads. Use when designing bursty workloads with minimal infrastructure and pay-per-execution cost model.

Applies coarse-grained service architecture for deployment independence. Use when independent deployment is needed but shared databases rule out microservices.

Applies data-grid architecture for high-traffic stateful workloads. Use when a single database cannot scale and in-memory partitioning is needed.

Polishes working code through successive quality passes in fresh subagents. Use after tests pass when code needs multi-dimension refinement before release.

Test skills via TDD in fresh subagents. Use when validating behavior or preventing bias.