athola

Assess whether to escalate models

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

Merges, dedupes, ranks, and formats research findings into a report. Use after research agents return results from multiple channels to produce a ranked report

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

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

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

Records browser sessions via Playwright and converts video to GIF

Plans, drafts, and refines technical tutorials for developers

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

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

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

Generates or remediates documentation with human-quality writing

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

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

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

Generates conventional commit messages from staged changes

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

Automates desktop GUI workflows via computer use API with screenshot capture

Audits shell scripts for correctness, portability, and common pitfalls

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

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

Autonomous orchestrator for manifest work items through the development lifecycle

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

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

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

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

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

Extracts writing style patterns from exemplar text into a reusable profile

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

Detects git forge (GitHub/GitLab/Bitbucket) and maps CLI commands cross-platform

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

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

Merges ephemeral report and analysis artifacts into permanent documentation

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

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

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

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

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

Detects workflow failures and inefficient patterns then files GitHub issues

Build composable skill modules with hub-and-spoke loading

Defines the contract for deferred-item capture across plugins

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

Detects AI-generated writing patterns in prose

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

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

Improves code quality across duplication, efficiency, and architectural fit

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

Generates markdown digests and CSV exports for GitHub initiative health

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

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

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

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

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

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

Generates a Mermaid dependency graph showing import relationships between modules

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

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

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

Selects and routes to the right architecture paradigm

Applies pipes-and-filters for sequential data transformations

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

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

Applies coarse-grained service architecture for deployment independence

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

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

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

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

Generates terminal recordings using VHS tape scripts and produces GIF outputs

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

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

Verifies math-heavy code for algorithmic correctness and numerical stability

Audits Makefiles for build correctness, portability, and recipe duplication

Assesses architecture decisions, ADR compliance, and coupling

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

Profiles Python code for performance bottlenecks and memory issues

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

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

Provisions the oracle ML inference daemon with onnxruntime via uv

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

Manages digital garden notes, link structures, and health metrics

Designs memory palace structures with spatial layouts and domain organization

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

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

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

Provides templates and lifecycle patterns for storage and documentation systems

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

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

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

Scores feature worthiness and enforces branch-size limits against overengineering

Formats review deliverables with consistent structure for comparable findings

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

Shapes agent behavior via instruction framing and style transfer

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

Summarizes recent git changes for context recovery after session breaks

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

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

Builds the gauntlet knowledge base from AST extraction and AI enrichment

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

Adds developer-authored annotations to the gauntlet knowledge base

Installs egregore watchdog daemon via launchd or systemd for autonomous relaunching

Removes the egregore watchdog daemon and its associated files

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

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

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

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

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

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

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

Recommends context compression strategies for bloated or quota-heavy sessions

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

Generates a Mermaid sequence diagram showing how data moves between components

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

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

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

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

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 modular monolith with enforced internal boundaries

Applies serverless FaaS patterns for event-driven workloads

Applies layered n-tier architecture with enforced boundaries

Applies microkernel architecture with minimal core and plugin extensibility

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 client-server architecture for web/mobile apps

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

Evaluate Claude skill quality through auditing

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

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

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

Surface expert frameworks

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

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

Searches and navigates stored knowledge in memory palaces

Provides sanitization guidelines for external content in skills and hooks

Searches GitHub for existing implementations, libraries, or patterns

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

Hunts bugs with evidence trails