89jobrien

Systematic testing of code variations, edge cases, boundary conditions, and alternative implementations. This skill provides methodologies and tools for exhaustive testing including input permutation, code path analysis, mutation testing, and implementation alternatives. Use when ensuring code robustness through comprehensive test coverage or when exploring edge cases and boundary conditions.

Specialized skill for MLX-based LLM fine-tuning on Apple Silicon. This skill should be used when working with LoRA fine-tuning, model conversion from HuggingFace to MLX format, adapter management, hyperparameter tuning, memory optimization, and benchmarking on M1/M2/M3/M4 chips.

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

n8n workflow development patterns, testing, validation, and best practices for building composable webhook workflows

Transforms workflow to use Manus-style persistent markdown files for planning, progress tracking, and knowledge storage. Use when starting complex tasks, multi-step projects, research tasks, or when the user mentions planning, organizing work, tracking progress, or wants structured output.

Use UV for Python dependency management. Use when setting up Python projects, creating Dockerfiles for Python apps, or managing dependencies & `pyproject.toml` files. UV provides deterministic resolution, speed, and reproducibility.

Convert PRDs to beads for ralph-tui execution. Creates an epic with child beads for each user story. Use when you have a PRD and want to use ralph-tui with beads as the task source. Triggers on: create beads, convert prd to beads, beads for ralph, ralph beads.

Audit godmode skills, agents, and plugin files for internal consistency, broken references, stale commands, and cross-skill contradictions. Use when asked to "introspect", "audit the skills", "review godmode", or after adding new skills.

Use at the start of every conversation to orient to available skills and workspace rules. Replaces superpowers entirely. Triggers on session start, "/godmode", or "what skills do you have".

Generate and maintain a `.ctx/godmode/memory-bank/` directory that captures project context backed by source code. The memory bank is injected into prompts via lifecycle hooks and updated incrementally as work progresses. Use when starting a new project, onboarding to an unfamiliar codebase, or when context drift is detected.

Patterns and techniques for adding governance, safety, and trust controls to AI agent systems in Rust. Use this skill when building agents that call external tools, implementing policy-based access controls, adding semantic intent classification to detect dangerous prompts, creating trust scoring systems for multi-agent workflows, building audit trails, or enforcing rate limits and content filters. Covers policy composition, tool wrappers, trust decay, and JSONL audit trails — all in Rust.

Parse git history into structured changelogs. Use to generate release notes, audit commit conventions before tagging, or integrate with `godmode release` workflow.

Dead code detector for Rust workspaces. Finds unused public API surface, orphaned test helpers, stale feature flags, and plugin artifacts referencing removed CLI subcommands. Cross-references pub exports against call sites across the workspace.

Triage and prioritize GitHub issues by type (bug/feature/chore), complexity (S/M/L), and priority (P1-P4). Detect duplicates, propose execution order, and generate task graphs for godmode automation.

Use when facing 2 or more independent tasks that have no shared state or sequential dependencies between them. Triggers on multiple failing tests from different root causes, independent crate implementations, or independent task chains in GODMODE.tasks.yaml.

Deep codebase analysis — architecture health, test coverage gaps, tech debt, and actionable findings

Run pre-commit checks (fmt, clippy, test) then stage, commit, and push with a conventional message

Review staged or recent changes for correctness, style, and Rust conventions before committing

Use when SSHing into remote machines, looking up credentials, renaming Tailscale devices, or accessing services on the tailnet. Symptoms - SSH auth failures, too many authentication failures, command not found tailscale, need to find credentials for remote machines.

Use when mixing Tokio async code with synchronous blocking I/O libraries (tar, flate2, zip, csv), or when seeing "cannot block the current thread from within the async context" panics, or needing to stream async bytes into a sync reader.

Structured BAML schema edit → validate → test loop for the devloop project. Use when editing any *.baml file in crates/baml/baml_src/ — covers version parity gotchas, uvx invocation, regeneration workflow, and the analyze verify step.

Use when reading large files (logs, JSONL, CSVs) that exceed context limits, when the Read tool returns truncated output, or when needing to locate a specific section in a multi-thousand-line file without reading everything.

Use when running daily maintenance across all repos — pull, analyze, fix P0s, synthesize to Obsidian, push. Invoke via /daily-orchestration or at start of day.

Use when the user runs "/insights-audit", asks to "validate the insights report", "audit the report against my projects", "check what the report got wrong", or wants to cross-check an /insights-generated HTML report against actual GitHub repos and local project directories.

This skill should be used when the user asks to "end session", "capture state", "session summary", "what changed this session", "summarize repos", "write session notes", or wants to capture multi-repo state at the end of a work session.

Fill in the Patterns & Surprises section of the latest session reflect file and write the completed review to .ctx/logs/self-review/. Use when the user runs "/self-review", asks to "fill in the reflect", "write the session review", or "what patterns did we hit".

Use when working on the rslm project — Recursive Language Model inference engine in Rust. Triggers on "rslm", "RLM", "recursive language model", "rhai built-ins", "ctx_grep", "ctx_slice", "rlm_call", "rslm-core", "rslm-providers", "rslm-store", or any question about running queries, ingesting documents, or writing Rhai scripts for the RLM loop.

This skill should be used when the user asks to "review this diff", "ai review", "security review my changes", "review before push", "check my code for issues", or wants an LLM-based security and correctness review of uncommitted or unpushed changes.

This skill should be used when the user asks to "generate commit message", "write a commit msg", "ai commit", "generate a conventional commit", "write my commit", or wants an LLM to draft a commit message from the staged diff.

Use this skill when the user says "build a harbor adapter", "adapt this benchmark for harbor", "harbor adapter for X", "port this benchmark to harbor", or wants to integrate any benchmark dataset into the Harbor evaluation framework (https://harborframework.com).

Use when the user wants to merge a branch, resolve conflicts, integrate remote changes, or recover from a push rejection. Covers push rejection triage, fetch, merge strategy selection, conflict resolution, and verification.

Remove AI-generated code slop by comparing current branch against base branch and eliminating unnecessary comments, defensive bloat, type workarounds, and style inconsistencies. Use this skill when reviewing AI-generated code, before merging PRs, when code quality seems degraded, or when you notice AI tells like excessive comments or defensive checks. Trigger for phrases like "remove slop", "clean AI code", "remove unnecessary code", "fix code quality", or when diff shows obvious AI-generated patterns.

Expert BAML (BoundaryML) schema design, code review, and test generation following established standards and conventions. Use this whenever users mention BAML, want to design AI functions, create schemas for LLM interactions, generate test cases, or review existing BAML code. Covers class/function/enum design, client configuration, prompt engineering, and comprehensive testing patterns.

Audit Claude Code agents, skills, commands, and hooks for quality, completeness, and adherence to templates and best practices. Use this skill when reviewing workspace components, ensuring quality standards, preparing for deployment, or investigating component issues. Trigger for phrases like "audit components", "check agents", "review skills", "validate commands", or proactively before major releases or when onboarding new components.

Comprehensive helper for working with the DevLoop development observability tool - both using it to analyze development patterns and contributing to its development. Use when running DevLoop commands, interpreting council mode analysis, understanding git activity patterns, reviewing Claude Code sessions, or working on DevLoop's hexagonal architecture codebase. Trigger for phrases like "run devloop", "analyze branch", "council mode", "development patterns", or when working on the DevLoop Rust codebase itself.

Remove emojis from project files and replace them with text equivalents. Use this skill when the user mentions removing emojis, cleaning up documentation, code review mentions emoji issues, or when you notice emojis in files that should be emoji-free. Also trigger for phrases like "clean emojis", "no emojis", "remove emoji", or "emoji cleanup".

Guide automated git bisect sessions to find regression commits with smart test execution and commit analysis. Use this skill when tracking down bugs introduced by specific commits, finding when tests started failing, debugging performance regressions, or investigating when features broke. Trigger for phrases like "find the bad commit", "when did this break", "bisect", "regression hunt", or when the user needs to identify which commit introduced an issue.

Automatically clean up merged branches, stale remotes, and organize repository structure. Use this skill when you notice merged branches, stale remote-tracking branches, cluttered branch lists, or when completing feature work. Trigger for phrases like "clean up branches", "delete merged branches", "prune remotes", "organize git", or when branch count exceeds 10-15 active branches. Also activate proactively after PR merges or when git branch output shows many [gone] references.

Navigate and understand minibox codebase architecture

Write an implementation plan as a markdown file, then immediately serialize it to a timestamped YAML task file in .ctx/tasks/. Use before touching any code when given a spec or approved design.

Design-first workflow for new features, components, or architecture decisions. Use before writing any code — get explicit approval on a design first.

Commit-and-push workflow with validation. Use when asked to "cap", "commit and push", or "ship it".

Systematic debugging for Rust. Use before proposing any fix — establish root cause first, then write a failing test, then fix.

Dispatch parallel subagents for independent tasks. Use when 2+ tasks have no shared state or sequential dependencies.

Task graph management for a session. Use to create tasks, track progress, execute the next unblocked task, or manage dependencies between work items.

Test-driven development workflow for Rust. Use before writing any implementation code — write a failing test first, then implement, then refactor.

Verification gate before claiming any work is complete. Use before committing, creating a PR, or reporting "done".

AgentExecutor, ChatAgent (ReAct), OpenAIToolsAgent, and the Agent trait.

JOB-251 — Why Arc<dyn LLM> over LLMClone, migration pattern, and correct LLM ownership model.

All Chain types — LLMChain, ConversationalChain, SequentialChain, StuffDocuments, ConversationalRetrievalQA, SqlDatabaseChain.

Trait conformance tests, property-based tests (proptest), fuzz targets, and boundary contracts for langchainx traits.

Core langchainx patterns — LLMChain, builder pattern, Chain trait, prompt macros, and basic invocation.

Constructing LLM backends (OpenAI, Claude, DeepSeek, Qwen, Ollama) and configuring CallOptions.

JOB-256 — blanket From impl, removing redundant Into impls, RwLock vs Mutex for memory.

BaseMemory trait, memory types (SimpleMemory, WindowBufferMemory, DummyMemory), and Arc<Mutex> construction patterns.

Debug or inspect classifier output for specific files or paths. Shows which rule fired and why. Use when the user asks "why was this classified as X", "what kind is this file", "debug classification", or wants to understand classifier behavior.

Absorb a foreign repo into the Rust ecosystem. Full pipeline: scan, classify, plan routing, generate hexagonal stubs, and execute. Use when the user says "cannibalize", "absorb", "strip", or points at a non-Rust repo to harvest. Orchestrates the scan -> plan -> gen -> eat pipeline with approval gates between stages.

Run cnbl eat to execute a migration plan -- copies generated stubs into destination repos and archives originals to the vault. Use when the user wants to "execute the plan", "absorb the files", "do the migration", or "eat it".

Run cnbl gen to create hexagonal Rust stubs from a migration plan. Generates domain types, port traits, and adapter skeletons. Use when the user wants to "generate stubs", "scaffold components", or "create Rust skeletons".

Run cnbl plan to route classified items to ecosystem repos. Takes scan JSONL as input, matches items against repos.json, and outputs routing decisions. Use when the user wants to "plan migration", "route items", or "decide where files go".

Run cnbl scan on a target repo to classify every file by kind (domain logic, port, adapter, script, spec, config, glue, discard). Outputs JSONL. Use when the user wants to "scan a repo", "see what's in a project", or "classify files".

Use when the user says "onboard me", "set up hand", "what does hand do", "walk me through setup", or invokes /hand:onboard. Guides through installation, verification, and first use of the hand session handoff plugin.

Use at end of a session to update HANDOFF.yaml with completed work, new gaps discovered, and current project state. Also use when asked to create a HANDOFF.yaml for a project that doesn't have one yet.

Use at the start of a session to orient to outstanding work — scans for HANDOFF.yaml (or HANDOFF.md) files, triages items by priority, and acts according to risk level without asking for approval on P1/P2 work.

This skill should be used when the user runs "/hand:over", asks to "visualize the handoff", "show handoff diagrams", "generate a handoff report", "explore the handoff", or provides a path to a HANDOFF file. Reads HANDOFF.*.{yaml,json,md} files and produces a prose summary plus Mermaid diagrams for project orientation.

Generate a daily activity report from Claude Code session data. Harvests human/assistant turns from ~/.claude/projects/*/*.jsonl, analyzes them with claude-haiku-4-5 via the Anthropic API, and renders an HTML report with KPI cards, goals table, and effort/leverage breakdown.

Use when merging multiple parallel agent branches (waves) into a single integration commit — rebasing each onto main, resolving conflicts while preserving intent, running tests per branch, and producing a clean summary commit with a conflict resolution log.

Minibox development skills — performance analysis, protocol sync audits, and release workflows for the minibox container runtime.

Guide for Rust error handling with Result<T,E>, error propagation, the ? operator, and custom error types using thiserror and anyhow

Guide for writing effective Rust tests with cargo test, unit tests, integration tests, and test organization

Design and author agentic workflows using the crux DSL — both YAML pipeline files (.crux) and Rust macro-based agents. Use when writing a .crux pipeline, designing an agent workflow, choosing between crux combinators (pipe, join_all, speculate, route_on_confidence, delegate), or planning how to decompose a task into crux steps. Triggers on "write a pipeline", "crux pipeline", ".crux file", "agentic workflow", "agent plan", "step handler", "which combinator", or any request involving pipeline design, step composition, or handler selection. Also use when reviewing or debugging existing pipelines.

Working with the crux codebase — an agentic Rust DSL and runtime trace model. Use when navigating crux source code, building crux from source, adding crux as a dependency, understanding crate boundaries, or debugging crux compilation issues. Triggers on "crux crate", "crux workspace", "crux build", "add crux dependency", "crux types", "CruxCtx", "Crux<T>", or any work inside the crux repo or a repo that depends on crux crates. Also use when someone asks about crux naming — the project was renamed from cruxx-* to crux-* in May 2026.