athola

Runs multi-source research across GitHub, HN, Reddit, arXiv, and Semantic Scholar

Searches academic literature via arXiv, Semantic Scholar, and open-access PDFs

Searches GitHub for existing implementations, libraries, or patterns

Creates clear, testable specifications from feature descriptions with user stories

Generates phased, dependency-ordered implementation tasks from specifications. Use after spec is complete and before starting implementation

Manages Claude Code sessions with naming, checkpointing, and resume strategies

Generates terminal recordings using VHS tape scripts and produces GIF outputs

Detects AI-generated writing patterns in prose

Plans, drafts, and refines technical tutorials for developers

Extracts writing style patterns from exemplar text into a reusable profile

Python package creation and PyPI distribution via pyproject.toml and entry points

Converts a Claude Code session JSONL file into an animated GIF terminal replay

Generates or remediates documentation with human-quality writing

Defines testing quality metrics, coverage thresholds, and anti-patterns

Bumps versions, updates changelogs, and coordinates version changes across files for releases

Classifies agent tasks into 4 risk tiers (GREEN/YELLOW/RED/CRITICAL)

Evaluates and improves skills, agents, commands, and hooks after a workflow slice

Refreshes README structure and content using repo context and exemplar research

Updates, generates, and validates tests using git-workspace context and TDD/BDD methodology

Generates or updates tutorials from VHS tapes and Playwright specs with dual-tone markdown and GIF recording

Recovers broken agent state via crash recovery, context overflow, and merge conflict protocols

Reviews pull requests with scope validation, requirements compliance, and line comments

Formats review deliverables with consistent structure for comparable findings

Updates documentation after code changes with quality gates, slop detection, and accuracy checks

Maps file structure and module organization of a codebase. Use before architecture reviews, refactoring planning, or migration scope estimation

Implements GitHub or GitLab issues via parallel subagents with review gates between task batches

Orchestrates multi-domain review (code, arch, tests, security) in a single pass

Audits Rust code for unsafe blocks, ownership issues, and Cargo dependency risks

Automates desktop GUI workflows via computer use API with screenshot capture

Detects time and space complexity hotspots via AST scan

Installs egregore watchdog daemon via launchd or systemd for autonomous relaunching

Audits shell scripts for correctness, portability, and common pitfalls

Applies NASA Power of 10 rules for safety-critical verifiable code

Selects optimal sources for tool calls, balancing accuracy with token cost. Use before research tasks or when deciding whether a claim needs verification

Enforces token quota management at session start with conservation and compression checks. Use at the start of every session or before large context loads

Optimizes context window via MECW principles and memory tiering

Manages context overflow by handing off to a fresh subagent at 80% usage

Generates a Mermaid class diagram showing types, inheritance, and composition

Selects and routes to the right architecture paradigm

Applies modular monolith with enforced internal boundaries

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

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

Assess whether to escalate models

Implements structured usage logging and audit trails for cost and session tracking

Assesses architecture decisions, ADR compliance, and coupling

Captures and retrieves PR-review findings in memory palaces. Use after PR review to store architectural decisions, patterns, and standards for future reference

Audits dependency supply chains for bad versions, lockfile drift, and artifact integrity

Searches and navigates stored knowledge in memory palaces

Evaluates test suites for coverage gaps, TDD/BDD compliance, and anti-patterns

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

Prepares pull requests by running quality gates, drafting descriptions, and validating tests

Runs a three-tier codebase audit (git history, targeted scans, full review) with gating

Manages digital garden notes, link structures, and health metrics

Registers external services with health checks, central config, and unified execution

Implements hub-and-spoke lazy loading to minimize token usage in large skills

Merges ephemeral report and analysis artifacts into permanent documentation

Generates conventional commit messages from staged changes

Applies microkernel architecture with minimal core and plugin extensibility

Applies KISS, YAGNI, and SOLID principles for clean code with reduced complexity

Configures GitHub Actions CI/CD workflows for testing, linting, and deployment

Recommends context compression strategies for bloated or quota-heavy sessions

Tracks per-agent token usage and flags waste in parallel dispatch

Delegates tasks to Gemini or Qwen with quota tracking and error handling

Delegates tasks to Gemini CLI implementing delegation-core for Google's models

Delegates tasks to Qwen CLI via delegation-core for Alibaba's models

Coordinates Claude agent teams via filesystem protocol

Detects architectural clusters and coupling boundaries via community detection on the code graph

Convenes a multi-LLM expert panel to pressure-test hard-to-reverse decisions

Generates a Mermaid architecture diagram showing high-level component relationships

Traces execution paths through the code graph with criticality scoring and Mermaid charts

Assesses decision reversibility and risk at critical checkpoints

Transforms project briefs into testable specifications with user stories and acceptance criteria. Use after brainstorming, before planning

Orchestrates full project lifecycle by auto-detecting state and routing to the correct phase

Scaffolds new projects with git, CI/CD workflows, pre-commit hooks, and build config

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

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

Configures pre-commit hooks for linting, type checking, formatting, and testing

Selects architecture paradigm via research before scaffolding

Generates Makefiles with testing, linting, formatting, and automation targets

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

Applies data-grid architecture for high-traffic stateful workloads

Applies serverless FaaS patterns for event-driven workloads

Applies microservices for independent deployment and per-service scaling

Applies event-driven async messaging to decouple producers and consumers

Applies hexagonal architecture isolating domain from infrastructure

Applies Functional Core, Imperative Shell to isolate logic from side effects

Test skills via TDD in fresh subagents

Applies CQRS and Event Sourcing for read/write separation and audit trails

Verifies math-heavy code for algorithmic correctness and numerical stability

Improves code quality across duplication, efficiency, and architectural fit

Audits Makefiles for build correctness, portability, and recipe duplication

Hunts bugs with evidence trails

Analyzes code change impact with risk scoring and affected-node mapping. Use before merging to understand what a change touches and what lacks test coverage

Evaluates API surface design, consistency, and exemplar alignment

Python testing patterns with pytest, fixtures, TDD, mocking, async and integration tests

Profiles Python code for performance bottlenecks and memory issues

Async Python patterns via asyncio and aiohttp for I/O-bound concurrency

Generates markdown digests and CSV exports for GitHub initiative health

Standardizes release approvals with GitHub-aware checklists and deployment gates. Use before releasing to production to verify all gates pass

Builds session-scoped temporary memory palaces for extended conversations

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

Processes external resources into stored knowledge with quality scoring and routing

Designs memory palace structures with spatial layouts and domain organization

Scores agent actions by expected gain, cost, uncertainty, and redundancy

Evaluate Claude skill quality through auditing

Applies stewardship virtues (Care, Curiosity, Humility, Diligence) to plugin work

Provides templates and lifecycle patterns for storage and documentation systems

Provides sem semantic-diff detection, install-on-first-use, and fallback patterns

Provides standardized pytest config, reusable fixtures, and CI integration patterns

Tracks quotas, monitors thresholds, and degrades gracefully for rate-limited APIs

Enforces markdown line-wrap and structure rules for clean git diffs

Converts documents and URLs to markdown via tiered fallback (MCP markitdown, native tools, user notice)

Provides weighted scoring, rubrics, and decision-threshold patterns

Provides error classification, recovery, and graceful-degradation patterns

Provides auth patterns for API keys, OAuth, and token management

Defines the contract for deferred-item capture across plugins

Scores feature worthiness and enforces branch-size limits against overengineering

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

Applies anti-sycophancy checklist to override agreement bias

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

Provides review-workflow scaffolding for context, evidence, and output. Use at the start of any detailed review to ensure consistent, comparable findings

Shapes agent behavior via instruction framing and style transfer

Analyzes changesets with risk scoring, categorization by type and impact, and release note preparation

Browse hookify rule catalog

Creates behavioral rules in markdown to block dangerous commands or restrict AI behavior

Guides a new developer through five staged challenge sets covering architecture, domain, patterns, and hardening

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

Surface expert frameworks

Searches the code knowledge graph by function, class, or type using FTS5 full-text search

Builds or updates the code knowledge graph via tree-sitter AST and SQLite

Presents adaptive codebase challenge questions with multiple-choice and trace exercises

Build composable skill modules with hub-and-spoke loading

Autonomous orchestrator for manifest work items through the development lifecycle

Orchestrates the QUALITY pipeline stage for egregore work items, running code review, unbloat, and test updates

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

Removes the egregore watchdog daemon and its associated files

Routes multi-tool workflows through MCP servers for large datasets and pipelines

Guides when to ask clarifying questions versus proceed autonomously. Use to reduce unnecessary clarifying questions when intent is clear

Establishes CPU/GPU baselines before resource-intensive operations. Use before builds, training runs, or any task that pins cores or GPUs for over a minute

Applies coarse-grained service architecture for deployment independence

Scans HN, Lobsters, Reddit, and tech blogs for community experience reports

Converts a Claude Code session into a blog post, case study, or Reddit post

Converts external documents (PDF, DOCX, PPTX, XLSX, HTML) into editable markdown

Provisions the oracle ML inference daemon with onnxruntime via uv

Provides sanitization guidelines for external content in skills and hooks

Scores backlog items with RICE/WSJF/Kano and files GitHub issues for top candidates

Adds developer-authored annotations to the gauntlet knowledge base

Generates a Mermaid dependency graph showing import relationships between modules

Generates a Mermaid workflow diagram showing process steps, decisions, and state transitions

Applies pipes-and-filters for sequential data transformations

Applies layered n-tier architecture with enforced boundaries

Applies client-server architecture for web/mobile apps

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

Compresses verbose responses by removing filler and framing to save 200-400 tokens

Detects codebase bloat via dead code, duplication, complexity, and doc bloat scans

Generates a Mermaid sequence diagram showing how data moves between components

Orchestrates Spec Driven Development by coordinating spec, plan, and task skills

Records browser sessions via Playwright and converts video to GIF

Converts webm/mp4 video files to optimized GIFs via ffmpeg with configurable quality settings

Combines GIFs and videos into composite tutorials with vertical or grid layouts via ffmpeg

Verifies workspace state and staged changes as a read-only preflight. Use before commits or PRs to confirm staged set is clean and correct

Refines an active research session by drilling deeper into a subtopic. Use after tome:research to narrow results to a specific channel or angle

Summarizes recent git changes for context recovery after session breaks

Builds the gauntlet knowledge base from AST extraction and AI enrichment

Applies TRIZ cross-domain analogical reasoning to find solutions from adjacent fields