Arasz

@arasz source repo

94 skills
0 followers
4 hours ago last updated

▌
QA 2 · arasz
Use when the user wants a question-and-answer session against a context — "qa {context}", "I have questions about X", or a question asked against supplied material — or wants the session's questions and grounded answers saved as a summary. If no context is given, ask for it first; every answer carries its grounding, and the session closes with a summary in docs.

0
installs
▌
Task 2 · arasz bundle
Use when the user wants to start, continue, or finish a backlog task — "/task <id>", "start task X", "work on the next task", "finish this task". Runs it end-to-end as a token-tracked unit of work with low/high effort, plan packaging with mandatory integration package, MoE panels for high-effort, and automated task-ID derivation ({repo-alias}-{key}). Delegates planning/review to high-reasoning models and implementation to persona-routed agents. Project specifics from .ai-badger/config.json; source-control and PR behaviour from config-gated extensions.

0
installs
▌
Auto Wm 2 · arasz bundle
Use when the user wants Claude to auto-approve tool calls — "enable autonomic/autonomous work mode", "/auto-wm", "partner mode", "work by yourself for N hours", "no one will be around to approve/answer" — or to check status, switch modes, or turn it off ("awm status", "auto-wm away 4h", "auto-wm off").

0
installs
▌
Git Work 2 · arasz bundle
Use when a git push fails for a reason the quality gate did not cause, CI goes red on a pushed branch, or a PR moves through review and merge outside the tracked-task flow: non-fast-forward recovery with force-with-lease, CI log triage and flake attribution, draft-to-squash PR lifecycle, squash-merge conventions, and join-time conflict resolution on plain branches.

0
installs
▌
Humanizer 2 · arasz
Use when writing or editing prose (documentation, blog posts, release notes, PR descriptions, emails) to strip AI writing artifacts, apply research-grounded humanization levers, and adopt a natural human voice.

0
installs
▌
MCP Index 2 · arasz bundle
Use when MCP tool selection needs help — the agent keeps picking the wrong tool, server tool definitions are bloating the prompt, or MCP servers were just added or removed. Manages .ai-badger/mcp-tools.json: tags, intent descriptions, and the hook that recommends tools per turn.

0
installs
▌
Quick Task 2 · arasz
Use when a change is small enough to skip the full task pipeline — one focused fix or small feature that fits a single commit on a branch cut from fresh main and merged via PR with auto-merge: a minimal plan, touched-surface tests only, the project's fast gates (lint, docs), one quick focused review, one commit per PR. Escalate to `task` the moment the change outgrows that shape.

0
installs
▌
Design Tests 2 · arasz bundle
Use when tests have to be designed or written for a target — "write tests for X", "add coverage here", "what should I test", a new behaviour with no test yet, a bug that needs a reproduction test, a coverage gap someone wants closed, or a bare "write some tests" with nothing named. Works with a target given or none given. Not for judging tests that already exist (review-tests) and not for diagnosing one already-flaky failure (dotnet-flaky-test-diagnosis).

0
installs
▌
Review Tests 2 · arasz bundle
Use when tests that already exist have to be judged rather than written — "are these tests any good", "review the tests in this PR", "why did the suite stay green while that shipped", a coverage number nobody trusts, a gate nobody has watched fail, a lane that flakes, or a test file a reviewer flagged. Takes a directory, a file list, a diff, or "the tests for X"; refuses to run with no target. Returns findings, not edits.

0
installs
▌
Send Message 2 · arasz bundle
Use when an agent session needs to reach another agent session, every session in a project, or every session on this machine without the human relaying between windows — 1:1, project-broadcast and machine-broadcast sends through the machine-wide user-DB message bus.

0
installs
▌
Test Economy 2 · arasz bundle
Use when a change's tests are about to run — deciding what to run locally (the modified surface and its consumers, once), what to leave to CI (the full suite, when CI is alive), and what to do when CI is dead (hooked-up local gates once, else one manual full-suite run before push) — or when full-suite runs start repeating and something must say stop. A PostToolUse hook counts shell test-runner commands, classifies full vs filtered, and commands the economy on the run past the session's budget; deliberate flake diagnosis is the one exempted repetition.

0
installs
▌
Browser Usage 2 · arasz
Use when interacting with web pages, running manual E2E browser tests, testing UI flows, or inspecting live web surfaces via Playwright MCP. Employs text-first accessibility snapshots and element refs, network inspection, form filling, and custom Playwright script execution.

0
installs
▌
Status Report 2 · arasz bundle
Use when the user asks where things stand mid-task — "status", "status report", "where are we", "what's the current task", "task progress", "what's next", "subagent status", "is the delegation done" — or wants a progress snapshot while work is still running. Answers NOW from the /task tracking files: current task, progress as a checklist, what is next, and sub-agent/delegation status. Important by default: never deferred to task end, never delegated, never turned into analysis.

0
installs
▌
Prompt Markers 2 · arasz bundle
Use when a prompt starts with a marker prefix — `h:`/`hint:` (a lead to validate before acting), `f:`/`feedback:` (a correction to apply immediately), `e:`/`extension:` (a request to widen scope), `q:`/`queue:` (a queued task for after current work), `i:`/`important:` (important, high priority) or `i!:`/`important!:` (immediate emergency interrupt) — every marker also accepts a `!` importance token between alias and colon, making it interrupt-grade — or when the user asks to add, change, or inspect those markers. The UserPromptSubmit hook detects them and injects the matching behaviour.

0
installs
▌
Commit Reminder 2 · arasz bundle
Use when a project has accumulated uncommitted changes and nobody has said so out loud — several edits in a row with no commit in between — or when a subagent may be stuck and about to lose its work ("did that agent commit?", "is anything at risk?", "ensure work is committed"). A PostToolUse hook watches the live `git status --porcelain` count after every edit-shaped tool call and commands a commit once it crosses a threshold; after repeated unanswered commands it records the work as at risk, and `scripts/ensure_committed.py` reports that to a parent.

0
installs
▌
Call Behaviorist 2 · arasz bundle
Use when ai-badger's own machinery needs to be observed — "did that hook even run?", "enable debug logging", "why is the drift notice silent?", "turn on the audit log", "what did the hooks do?" — or to check, tail, or switch off that logging. Records which hook ran, in which project, under which version, to an append-only log.

0
installs
▌
Create Task Spec 2 · arasz bundle
Use when a feature idea needs to become an exact, agreed specification before anyone builds it — "spec this out", "create a task spec", "turn this idea into requirements", "what exactly should we build". Interrogates the person for what they know instead of proposing content for them to approve, using Gherkin's own grammar to decide which questions must be asked and when the document is complete. Emits a .feature behavioural contract plus a spec.json manifest that the task skill consumes.

0
installs
▌
Code Review 2 · arasz bundle
Use when performing a code review in this repository — reviewing a pull request, a branch diff, or a requested re-review. This is the review entry point GitHub Copilot code review loads from .github/skills/ (a review-focused skill name and description, as GitHub's docs recommend); it routes to the deeper review skills this project ships — risk ranking, pass/fail gates, test-quality judgement, whole-project review — adjusted per project stack. Trigger phrases: "review this PR", "review these changes", "code review", "is this safe to merge".

0
installs
▌
AI Raccoon Memory 2 · arasz bundle
Use when a project needs a memory server — search project and shared memory first, write durable facts with source paths, watch a docs directory, or promote facts across projects.

0
installs
▌
Owner Gate Review 2 · arasz bundle
Use when a design, refactor or review document needs a per-decision ruling from one human reviewer and the answers must come back attached to the decision they belong to. Triggers: pasting a long document into chat and getting a wall of prose back, an answer that can't be matched to its question, a reviewer hand-editing answer slots in markdown, or a set of decisions that must each be approved, changed, rejected or deferred before work is scoped.

0
installs
▌
Code Review Checklist 2 · arasz bundle
Use when reviewing code — a PR, a diff, or freshly written changes — and you want concrete pass/fail checks rather than impressions. An aviation-style preflight checklist organised into sequential phases, with stack-specific items merged in from the project's config.

0
installs
▌
Multi Agent Communication 2 · arasz
Use when multiple agent sessions share one project and must coordinate without stepping on each other — announcing started work, touched files, opened PRs, review requests, review feedback, and merges to main over the project message bus. Covers when to broadcast, the message shape, and the ack-without-reply rule that keeps the bus loop-free.

0
installs
▌
Semantica Knowledge Graph 2 · arasz bundle
Use when reasoning over structured project knowledge — record decisions with provenance, trace causal chains, extract entities from conversations, or run graph analytics. Complements AiRaccoon memory (recall) with structured reasoning (connections and causality).

0
installs
▌
Code Review Checklist 3 · arasz bundle
Use when reviewing code — a PR, a diff, or freshly written changes — and you want concrete pass/fail checks rather than impressions. An aviation-style preflight checklist organised into sequential phases, with stack-specific items merged in from the project's config.

0
installs
▌
Maintain Agent Instructions 2 · arasz bundle
Use when agent instruction files have drifted from each other or from the policy model — CLAUDE.md, copilot-instructions.md, AGENTS.md, hosted-review and path-scoped instruction files — or when validation/drift checks fail in CI. Reconciles them from the machine-readable model in .ai-badger/agent-instructions/.

0
installs
▌
Differential Feature Refactor 2 · arasz bundle
Use when a feature already exists in code but has drifted from — or was never reconciled with — its intended design, and someone must decide what changes before a refactor is scoped. Triggers: two parallel implementations of the same thing, code that reads as dead but may be a ratified extension point, an architecture nobody can tell from accumulated cruft, or a refactor about to be scoped off review documents instead of decisions.

0
installs
▌
Complete Project Scope Code Review 2 · arasz bundle
Use when the whole project — not a diff — is the review target and the result must survive being acted on: "review the entire codebase", "full quality review", "MoE review", "what is wrong with this project", "audit everything before the next release", or a review whose findings will become a plan someone implements. Runs ground-truth baseline, parallel expert lanes, integration, an adversarial pass that tries to falsify the findings, severity calibration against production reality, a reviewed plan, waved implementation in isolated worktrees, and a join review on every merge. Not for judging one diff or PR (that is review-changes plus code-review-checklist), one design document's gates (design-gate-audit), or one question (evidence-first-research).

0
installs
▌
QA · arasz bundle
Use when the user wants a question-and-answer session against a context — "qa {context}", "I have questions about X", or a question asked against supplied material — or wants the session's questions and grounded answers saved as a summary. If no context is given, ask for it first; every answer carries its grounding, and the session closes with a summary in docs.

0
installs
▌
Task · arasz bundle
Use when the user wants to start, continue, or finish a backlog task — "/task <id>", "start task X", "work on the next task", "finish this task". Runs it end-to-end as a token-tracked unit of work with low/high effort, plan packaging with mandatory integration package, MoE panels for high-effort, and automated task-ID derivation ({repo-alias}-{key}). Delegates planning/review to high-reasoning models and implementation to persona-routed agents. Project specifics from .ai-badger/config.json; source-control and PR behaviour from config-gated extensions.

0
installs
▌
Auto Wm · arasz bundle
Use when the user wants Claude to auto-approve tool calls — "enable autonomic/autonomous work mode", "/auto-wm", "partner mode", "work by yourself for N hours", "no one will be around to approve/answer" — or to check status, switch modes, or turn it off ("awm status", "auto-wm away 4h", "auto-wm off").

0
installs
▌
Git Work · arasz bundle
Use when a git push fails for a reason the quality gate did not cause, CI goes red on a pushed branch, or a PR moves through review and merge outside the tracked-task flow: non-fast-forward recovery with force-with-lease, CI log triage and flake attribution, draft-to-squash PR lifecycle, squash-merge conventions, and join-time conflict resolution on plain branches.

0
installs
▌
Humanizer · arasz bundle
Use when writing or editing prose (documentation, blog posts, release notes, PR descriptions, emails) to strip AI writing artifacts, apply research-grounded humanization levers, and adopt a natural human voice.

0
installs
▌
MCP Index · arasz bundle
Use when MCP tool selection needs help — the agent keeps picking the wrong tool, server tool definitions are bloating the prompt, or MCP servers were just added or removed. Manages .ai-badger/mcp-tools.json: tags, intent descriptions, and the hook that recommends tools per turn.

0
installs
▌
Quick Task · arasz bundle
Use when a change is small enough to skip the full task pipeline — one focused fix or small feature that fits a single commit on a branch cut from fresh main and merged via PR with auto-merge: a minimal plan, touched-surface tests only, the project's fast gates (lint, docs), one quick focused review, one commit per PR. Escalate to `task` the moment the change outgrows that shape.

0
installs
▌
Den Refresh · arasz bundle
Use when an already-scaffolded project is behind the framework — a drift notice appeared, a new ai-badger version shipped, or the user asks to "refresh"/"update ai-badger". Reports what changed, backs up .ai-badger/, and re-scaffolds from the project's existing config.

0
installs
▌
Feed Badger · arasz bundle
Use when something learned in this repo belongs in the ai-badger framework itself — a new skill, persona, invariant, instruction or fix that is project-agnostic — and the user wants to contribute it back. Opens a draft PR against the framework; refuses anything project-specific.

0
installs
▌
Design Tests · arasz bundle
Use when tests have to be designed or written for a target — "write tests for X", "add coverage here", "what should I test", a new behaviour with no test yet, a bug that needs a reproduction test, a coverage gap someone wants closed, or a bare "write some tests" with nothing named. Works with a target given or none given. Not for judging tests that already exist (review-tests) and not for diagnosing one already-flaky failure (dotnet-flaky-test-diagnosis).

0
installs
▌
Review Tests · arasz bundle
Use when tests that already exist have to be judged rather than written — "are these tests any good", "review the tests in this PR", "why did the suite stay green while that shipped", a coverage number nobody trusts, a gate nobody has watched fail, a lane that flakes, or a test file a reviewer flagged. Takes a directory, a file list, a diff, or "the tests for X"; refuses to run with no target. Returns findings, not edits.

0
installs
▌
Send Message · arasz bundle
Use when an agent session needs to reach another agent session, every session in a project, or every session on this machine without the human relaying between windows — 1:1, project-broadcast and machine-broadcast sends through the machine-wide user-DB message bus.

0
installs
▌
Test Economy · arasz bundle
Use when a change's tests are about to run — deciding what to run locally (the modified surface and its consumers, once), what to leave to CI (the full suite, when CI is alive), and what to do when CI is dead (hooked-up local gates once, else one manual full-suite run before push) — or when full-suite runs start repeating and something must say stop. A PostToolUse hook counts shell test-runner commands, classifies full vs filtered, and commands the economy on the run past the session's budget; deliberate flake diagnosis is the one exempted repetition.

0
installs
▌
Browser Usage · arasz bundle
Use when interacting with web pages, running manual E2E browser tests, testing UI flows, or inspecting live web surfaces via Playwright MCP. Employs text-first accessibility snapshots and element refs, network inspection, form filling, and custom Playwright script execution.

0
installs
▌
Status Report · arasz bundle
Use when the user asks where things stand mid-task — "status", "status report", "where are we", "what's the current task", "task progress", "what's next", "subagent status", "is the delegation done" — or wants a progress snapshot while work is still running. Answers NOW from the /task tracking files: current task, progress as a checklist, what is next, and sub-agent/delegation status. Important by default: never deferred to task end, never delegated, never turned into analysis.

0
installs
▌
Prompt Markers · arasz bundle
Use when a prompt starts with a marker prefix — `h:`/`hint:` (a lead to validate before acting), `f:`/`feedback:` (a correction to apply immediately), `e:`/`extension:` (a request to widen scope), `q:`/`queue:` (a queued task for after current work), `i:`/`important:` (important, high priority) or `i!:`/`important!:` (immediate emergency interrupt) — every marker also accepts a `!` importance token between alias and colon, making it interrupt-grade — or when the user asks to add, change, or inspect those markers. The UserPromptSubmit hook detects them and injects the matching behaviour.

0
installs
▌
Commit Reminder · arasz bundle
Use when a project has accumulated uncommitted changes and nobody has said so out loud — several edits in a row with no commit in between — or when a subagent may be stuck and about to lose its work ("did that agent commit?", "is anything at risk?", "ensure work is committed"). A PostToolUse hook watches the live `git status --porcelain` count after every edit-shaped tool call and commands a commit once it crosses a threshold; after repeated unanswered commands it records the work as at risk, and `scripts/ensure_committed.py` reports that to a parent.

0
installs
▌
Call Behaviorist · arasz bundle
Use when ai-badger's own machinery needs to be observed — "did that hook even run?", "enable debug logging", "why is the drift notice silent?", "turn on the audit log", "what did the hooks do?" — or to check, tail, or switch off that logging. Records which hook ran, in which project, under which version, to an append-only log.

0
installs
▌
Create Task Spec · arasz bundle
Use when a feature idea needs to become an exact, agreed specification before anyone builds it — "spec this out", "create a task spec", "turn this idea into requirements", "what exactly should we build". Interrogates the person for what they know instead of proposing content for them to approve, using Gherkin's own grammar to decide which questions must be asked and when the document is complete. Emits a .feature behavioural contract plus a spec.json manifest that the task skill consumes.

0
installs
▌
AI Raccoon Memory · arasz bundle
Use when a project needs a memory server — search project and shared memory first, write durable facts with source paths, watch a docs directory, or promote facts across projects.

0
installs
▌
Owner Gate Review · arasz bundle
Use when a design, refactor or review document needs a per-decision ruling from one human reviewer and the answers must come back attached to the decision they belong to. Triggers: pasting a long document into chat and getting a wall of prose back, an answer that can't be matched to its question, a reviewer hand-editing answer slots in markdown, or a set of decisions that must each be approved, changed, rejected or deferred before work is scoped.

0
installs
▌
Welcome AI Badger · arasz bundle
Use when a repository should be set up with ai-badger — "welcome-ai-badger", "scaffold this project", "add agent instructions here", "onboard this repo" — whether it is new or already has agent files. Detects stacks, writes .ai-badger/, and generates each configured agent's discovery file.

0
installs
▌
Code Review Checklist · arasz bundle
Use when reviewing code — a PR, a diff, or freshly written changes — and you want concrete pass/fail checks rather than impressions. An aviation-style preflight checklist organised into sequential phases, with stack-specific items merged in from the project's config.

0
installs
▌
Code Review · arasz
Use when performing a code review in this repository — reviewing a pull request, a branch diff, or a requested re-review. This is the review entry point GitHub Copilot code review loads from .github/skills/ (a review-focused skill name and description, as GitHub's docs recommend); it routes to the deeper review skills this project ships — risk ranking, pass/fail gates, test-quality judgement, whole-project review — adjusted per project stack. Trigger phrases: "review this PR", "review these changes", "code review", "is this safe to merge".

0
installs
▌
Debug Issue · arasz
Use when a bug report or failing test names a symptom and the code path producing it is not yet known — trace the call chain from symptom to entry point before proposing a fix. Trigger phrases: "why does this fail", "trace this bug", "find where this is called from", "what calls this function", "did a recent change cause this". Not a replacement for the general reproduce-isolate-fix discipline (a `systematic-debugging` skill, if present, governs that overall loop); reach for this skill specifically for the tracing step — once a symptom is located and the call chain to its entry point still needs walking before a hypothesis is formed.

0
installs
▌
Documentation · arasz bundle
Use when a task concerns the project's documentation tree itself — creating it where none exists, updating or amending documents in it, or migrating/reorganising an existing docs layout — and you must pick which specialized documentation skill covers it. This gateway routes; read manifest.json to choose a member and open that member's SKILL.md. Not for writing prose inside a document that already has a home.

0
installs
▌
Review Changes · arasz
Use when reviewing a diff, PR, or a batch of changed files and you need to know where the risk concentrates — which changed units have the largest blast radius, whether the highest-risk ones are actually covered by tests, and whether the result is safe to merge. Trigger phrases: "review these changes", "how risky is this diff", "what's the blast radius", "did anything untested change", "rank these changes by risk". Not for a pass/fail preflight of style, security, and layering checks — that is `code-review-checklist`; run the checklist for the mechanical gates and reach for this skill to decide where its attention should concentrate. The two compose: checklist for gates, this skill for prioritization.

0
installs
▌
Multi Agent Communication · arasz bundle
Use when multiple agent sessions share one project and must coordinate without stepping on each other — announcing started work, touched files, opened PRs, review requests, review feedback, and merges to main over the project message bus. Covers when to broadcast, the message shape, and the ack-without-reply rule that keeps the bus loop-free.

0
installs
▌
Semantica Knowledge Graph · arasz bundle
Use when reasoning over structured project knowledge — record decisions with provenance, trace causal chains, extract entities from conversations, or run graph analytics. Complements AiRaccoon memory (recall) with structured reasoning (connections and causality).

0
installs
▌
Refactor Safely · arasz
Use when renaming, moving, extracting, or removing code and every affected location must be known before the first edit — a rename that spans call sites, an extraction that changes a signature, or a removal that might delete something still in use. Trigger phrases: "refactor this safely", "rename X everywhere", "is this code still used", "find everything that calls this before I change it", "preview this refactor". Not for reconciling a feature whose implementation has drifted from its intended design — that is `differential-feature-refactor`, a design question to answer first; this skill is the mechanical preview-apply-verify discipline once the refactor's scope is already known.

0
installs
▌
Explore Codebase · arasz
Use when arriving at an unfamiliar codebase, or an unfamiliar region of a known one, and the question is "what is here and how is it arranged" rather than "where is this specific thing". Trigger phrases: "help me understand this repo", "what does this project do", "where does X live", "walk me through the architecture", "I'm new to this codebase", "what are the main modules". Not for tracing one symptom to its cause — that is `debug-issue`; not for judging a diff — that is `review-changes`. Reach for this one when orienting, and switch to those once you know where to look.

0
installs
▌
Maintain Agent Instructions · arasz bundle
Use when agent instruction files have drifted from each other or from the policy model — CLAUDE.md, copilot-instructions.md, AGENTS.md, hosted-review and path-scoped instruction files — or when validation/drift checks fail in CI. Reconciles them from the machine-readable model in .ai-badger/agent-instructions/.

0
installs
▌
Differential Feature Refactor · arasz bundle
Use when a feature already exists in code but has drifted from — or was never reconciled with — its intended design, and someone must decide what changes before a refactor is scoped. Triggers: two parallel implementations of the same thing, code that reads as dead but may be a ratified extension point, an architecture nobody can tell from accumulated cruft, or a refactor about to be scoped off review documents instead of decisions.

0
installs
▌
Dotnet Workload · arasz bundle
Use when working on any .NET workload concern — BDD/Reqnroll testing, immutable domain modeling, flaky test diagnosis, BackgroundService/IHostedService review or testing, [LoggerMessage] log-line design, MCP servers in .NET, SQLCipher-encrypted SQLite, System.CommandLine CLI parsing, .NET tool/NuGet publishing, or an observability/instrumentation review — and you must pick which specialized dotnet skill covers it. This gateway routes; read manifest.json to choose a member and open that member's SKILL.md for the deep guidance.

0
installs
▌
Design Gate Audit · arasz bundle
Use when auditing a design doc's acceptance gates BEFORE implementation: check every gate would fail if the feature were broken (HONEST) and the named test file/framework/seam exists (FEASIBLE). Attacks vacuous negatives, timing-window vacuity, port races, env poisoning, unprovable real-time halves. Pairs with dotnet-hosted-service-testing for FakeTimeProvider mechanics.

0
installs
▌
Cron Watchdog Authoring · arasz
Use when scheduling a Hermes cron job or writing a watchdog script: recurring schedules need 'every 30m' (bare '30m' is ONE-SHOT — check repeat), no_agent+script shape, silent-unless-action stdout discipline, version-gated rollout watchdogs (marker files, surgical port-kill), idempotent ticks, and verifying CLI verb paths before the rollout branch can run.

0
installs
▌
Evidence First Research · arasz bundle
Use when a question needs investigating and the answer will be acted on — "research X", "look into whether Y", "find out how Z works", "is this worth doing", "compare these options", a benchmark someone will quote, or a claim that has to survive being challenged. Produces a dated record where every finding carries how it is known — measured, read, inferred, or unverified — plus a self-contained HTML view. Not for locating code (that is explore-codebase), tracing one symptom (debug-issue), or judging a diff (review-changes); reach for this when the output is a set of findings someone else will rely on.

0
installs
▌
Worktree Agent Isolation · arasz bundle
Use when running multiple agents in parallel, or when the user says 'worktrees only', 'agent isolation', 'parallel workstreams', or 'don't touch main': give each agent its own git worktree branched from origin/main (fetch first), integrate via GitHub PRs, keep the main checkout read-only, and avoid shared obj/ races and file-modification conflicts.

0
installs
▌
Hermes Plugin Development · arasz bundle
Use when writing or debugging Hermes Agent Python plugins — including the memory-provider specialized plugin type: directory-plugin packaging (plugin.yaml + __init__.py with register(ctx) — flat .py files are INVISIBLE), VALID_HOOKS list, per-hook payload keys (no cwd; tool_name vs function_name), plugins.enabled opt-in, pre_llm_call context injection, stash/pop for post_tool_call, HERMES_PLUGINS_DEBUG=1, and the MemoryProvider ABC with its threading & lifecycle contract.

0
installs
▌
Code Review Evidence · arasz bundle
Use when reviewing code that wraps external libs/extensions/SDKs/CLIs, or QA-reviewing a test harness: verify wrapped-library semantics from the upstream source (not comments/spec), query the real store read-only for data claims, and hunt tautological tests that assert values the code constructed itself. Catches spec-vs-coverage gaps, fake honesty, hygiene.

0
installs
▌
Sqlite Schema Review · arasz
Use when reviewing SQLite schema/migration changes: DDL, on-open migrations, unique indexes, insert-path dedup, ON CONFLICT DO NOTHING scope, last_insert_rowid staleness, trigger fire-time failures, UNIQUE-index NULL semantics. Core rule: verify every semantics claim against a scratch DB — never the plan, PR, or docs.

0
installs
▌
Artifact Verification · arasz bundle
Use when verifying changed artifacts that lack a canonical test gate — specs, docs, manifests, generated files, published packages: use the workflow-defined checker first (spec_holes.py), review manual fresh-install protocols against the false-pass checklist, and verify 'installed build contains merged PR X' by tree comparison, never squash-ancestry.

0
installs
▌
Research Record Audit · arasz bundle
Use when auditing a research record's factual accuracy, citation truth, or grade correctness: adversarially re-derive every load-bearing claim from cited sources, verify quotes verbatim at cited lines, re-run MEASURED claims, audit grade honesty (INFERRED hedged, UNVERIFIED plain), check negative claims for prune/retention explanations, and report ACCURATE/CORRECTED/OVERCLAIMED.

0
installs
▌
MCP Tool Surface Testing · arasz bundle
Use when testing every tool an MCP server exports: black-box expectations-first audit (expectations → call → compare), live contract vs docs-drift findings, destructive-tool safety controls, dependency-ordered execution, and a results doc committed to the repo. Triggers: 'test all tools', 'does every MCP tool work', server surface changed.

0
installs
▌
Pre Push Gate Debugging · arasz
Use when a pre-push quality gate blocks git push or a lane fails: read the gate's own logs first (reproduce one lane), run single lanes for fast iteration, test the working tree you intend to push, handle E2E/infra cross-run state contamination, worktree node_modules gotchas, and build a manual repro harness when lane output hides the real error.

0
installs
▌
Spec Driven Refactoring · arasz bundle
Use when the user says 'refactor', 'migrate', or 'rename across the codebase', or a change touches 5+ files across schemas, scripts, tests, and docs: write a spec, run two review gates (pre-implementation consistency + post-implementation quality), then implement against it. Covers schema migrations, concept renames, structural reorganizations.

0
installs
▌
Scripts Tooling Refactor · arasz bundle
Use when refactoring a repo's scripts/ directory: convert non-python scripts to the repo's tooling language, move logic to src/ with tests in tests/ (TDD first), prune dead scripts on usage evidence (git ls-files inventory, LIVE/HISTORICAL classification, three-way sync contracts), and preserve call sites with thin wrappers.

0
installs
▌
Documentation Drift Audit · arasz bundle
Use when auditing docs for drift vs code ('audit and fix documentation drift'): inventory claims with path:line, verify each against real files (scaffolders, manifests, hooks), classify verifiably-false vs design-position vs ambiguous vs historical, fix only the false, and report A/B/C. Also for post-merge doc-gap audits and user-facing doc compaction rewrites.

0
installs
▌
Multi Lane Report Assembly · arasz bundle
Use when assembling outputs from 2+ parallel research/review lanes into one evidence-graded record: lift finding blocks verbatim from the authoritative full summaries (never the truncated delegation transcripts), enforce the lane contract (### F# — claim [GRADE], Evidence line), truncate at embedded '## Still open' headers, renumber, and gate the result.

0
installs
▌
Sqlite Bank Space Diagnosis · arasz
Use when a SQLite bank file or WAL is bloated: diagnose space read-only first (snapshot backup, sqlite3_analyzer, wal_checkpoint(TRUNCATE), VACUUM INTO to quantify reclaim), explain WAL growth mechanics (checkpointed-but-untruncated frames under pooling), the vec0 chunk count(*) trap, and VACUUM/checkpoint/ANALYZE ordering.

0
installs
▌
Complete Project Scope Code Review · arasz bundle
Use when the whole project — not a diff — is the review target and the result must survive being acted on: "review the entire codebase", "full quality review", "MoE review", "what is wrong with this project", "audit everything before the next release", or a review whose findings will become a plan someone implements. Runs ground-truth baseline, parallel expert lanes, integration, an adversarial pass that tries to falsify the findings, severity calibration against production reality, a reviewed plan, waved implementation in isolated worktrees, and a join review on every merge. Not for judging one diff or PR (that is review-changes plus code-review-checklist), one design document's gates (design-gate-audit), or one question (evidence-first-research).

0
installs
▌
Review Gate Diff Verification · arasz
Use when a review gate judges a branch diff: verify the diff base FIRST — merge-base vs moved origin/main ref (phantom D/M files), grep anchors after the status tab, exclude bin/obj from symbol greps, and diff the committed plan against the accepted amended version before judging implementation.

0
installs
▌
AI Raccoon Manual Checklist · arasz bundle
Use when hand-verifying a live AiRaccoon build — a pre-flight or release checklist, a manual smoke test after installing the global tool, a "does this actually work end to end" pass before shipping, or any question `dotnet test` cannot answer because it needs a real install, a real server and a real bank. Derives the version and tool surface from the product instead of pinning them, records the command and the output behind every answer, and writes the filled checklist to docs/work/checklist/.

0
installs
▌
Update Documentation · arasz bundle
Use whenever documentation must change to match something that already changed — after a code change, ADR, schema change or PR lands, and when the user says "update the docs", "document this", "add a how-to for X", "the README is wrong", "this doc is stale", or a reviewer reports docs drift. Also use before creating any new document, to decide where it belongs. Triggers include a doc that contradicts the code, a fact nobody can source, and a new page with no obvious home. Not for creating the docs tree (use scaffold-documentation) and not for reorganising it wholesale (use migrate-documentation).

0
installs
▌
Migrate Documentation · arasz
Use when an existing documentation tree must be reorganised wholesale — "migrate the docs", "reorganise docs/", hundreds of files with no structure, overlapping documents that contradict each other, a docs directory nobody can navigate, or documentation whose accuracy is unknown and must be established before anyone relies on it. Also use to resume a migration already in progress. Not for creating a tree that does not exist (use scaffold-documentation) and not for a single documentation change (use update-documentation).

0
installs
▌
Scaffold Documentation · arasz bundle
Use when a repository has no documentation tree yet, or the canonical docs layout is missing, incomplete or was hand-created — "set up docs", "scaffold documentation", "create the docs structure", a fresh repo with only a README, a docs directory missing its directory READMEs, or a structure check that reports absent directories. Not for adding or editing a document (use update-documentation), and not for reorganising docs that already exist (use migrate-documentation).

0
installs
▌
Dotnet MCP Server · arasz bundle
Use when adding MCP (Model Context Protocol) tools or servers to a .NET project: tool/prompt registration with [McpServerTool]/[McpServerPrompt], stdio or Streamable-HTTP host wiring (dual-mode, port traps), DI + typed HttpClient for REST-backed tools, unit tests with mock HTTP handlers, tool-inventory tests that assert the REGISTERED surface, and SDK 2.x specifics (McpException error signaling, request filters, tool-name derivation).

0
installs
▌
Dotnet Bdd Testing · arasz bundle
Use when adding Gherkin .feature files / a BDD runner to a .NET project: Reqnroll is the only live option (SpecFlow is EOL — never recommend it), xunit.v3 + CPM integration, tags/@ignore/Skip and Rule: blocks, or un-ignoring dormant scenarios. Includes the build-time code-behind recipe, feature-file overlap policy, and verified package facts.

0
installs
▌
Dotnet Domain Modeling · arasz bundle
Use when modeling immutable C#/.NET domain layers: sealed records with required/init props, CommunityToolkit.Diagnostics guards (and when to hand-roll them), state-transition methods, policy objects, extension-point interfaces (DIM), FluentValidation nested validators, ArchUnitNET purity enforcement — with TDD for pure domain layers. Triggers: DDD aggregates/value objects, domain-purity rules, validator design.

0
installs
▌
Dotnet Tool Publishing · arasz bundle
Use when packaging or publishing a .NET CLI tool (PackAsTool) or library to NuGet: the MSB3030 build-before-pack trap (and its Web-SDK inversion), multi-RID matrix shells + the shell-race fix, gitignored bundled assets, Trusted Publishing/OIDC with human approval gates, the 409-published-nothing diagnosis, ToolCommandName/PATH shim rules, and full fresh-install verification for MCP tools with bundled models.

0
installs
▌
Dotnet System Commandline · arasz bundle
Use when adding CLI argument parsing to a .NET app or dotnet tool: System.CommandLine 2.0.x GA idioms (parse-first, HelpAction/VersionOptionAction detection, Option.Validators, FromAmong), parser-landscape verdicts (Cocona archived — don't adopt), and the stdio-MCP trap where help/version must render to stderr. Includes Cocona-maintenance guidance for existing tools.

0
installs
▌
Dotnet Flaky Test Diagnosis · arasz bundle
Use when a .NET test fails in the full suite but passes alone (or flakes intermittently): classify via the ladder — intra-test race (lock-guard fake collections), inter-test contention (xunit v3 DisableParallelization collections), or environmental flakes (child PATH/env, cold-worktree asset provisioning) — before blaming the branch. Includes the clean-main baseline check and gate discipline.

0
installs
▌
Dotnet Sqlcipher Encryption · arasz bundle
Use when working with SQLCipher-encrypted SQLite in .NET (e_sqlite3mc / SQLitePCLRaw bundle): raw 256-bit keys via Password='x'<hex>'', deriving keys from ed25519 SSH keys, PRAGMA rekey constraints (WAL unsupported), pluggable key-source providers (env/keychain/vault) with the pre-open sidecar pattern, and Dapper-over-SQLite3MC mapping traps.

0
installs
▌
Dotnet Hosted Service Review · arasz
Use when reviewing a PR that adds or modifies a .NET BackgroundService/IHostedService — background extraction loops, watchers, sync, sweep, or any poll loop. Checklist: ExecuteAsync try/catch coverage (StopHost kills the process), cancellation filtering, PeriodicTimer semantics, store-level idempotency vs TOCTOU, settings-channel parsing, LoggerMessage invariants. Produces numbered findings + severity + file:line.

0
installs
▌
Dotnet Logger Message Design · arasz bundle
Use when designing or testing [LoggerMessage] log lines in .NET: nested static partial Log classes, explicit EventIds with per-category ranges, no call-site interpolation, collection parameters (pre-join at the call site), per-item detail logs vs counts, and FakeLogger-based log assertions (generic vs non-generic compile contract, LatestRecord/AllRecords, RED-first EventId tests).

0
installs
▌
Dotnet Hosted Service Testing · arasz bundle
Use when writing or reviewing .NET BackgroundService tests with FakeTimeProvider/TimeProvider: lost-first-Advance semantics, inline-vs-threadpool timer callbacks, poll-loop test honesty (invocation counters, not side-effect counts), tick derivation from timeouts, DI registration smoke tests, vacuous-gate detection. Verified on .NET 10; includes an empirical probe script.

0
installs
▌
Observability Contract Review · arasz bundle
Use when reviewing claims that 'all calls are instrumented': span+metrics helper diffs, tool-layer try/catch instrumentation, N/N tool-surface parity tests. Checks path coverage, not call-site presence — filtered-catch escape holes, exactly-once recording, Activity status/tag ordering, instrumentation-test honesty, CI Speed-trait blind spots, metrics-unchanged verification.

0
installs

94 published skills