Latest Agent Skills

Performs finite element analysis, computational fluid dynamics, thermal analysis, modal analysis, and design optimization for validating designs against physical loads and predicting product behavior.

Creates 2D drawings and 3D models of mechanical parts, generates technical documentation and manufacturing files, and supports assembly design and parametric modeling.

Writes Behavior-Driven Development scenarios using Gherkin syntax to create executable specifications and test behavior.

Design and implement AWS architectures with best practices for IAM, S3, Lambda, DynamoDB, and serverless deployments.

Assists with software engineering tasks including writing, editing, and explaining code, searching codebases, running commands, managing files, debugging, and implementing features.

Enforces running verification commands and confirming output before claiming work is complete, fixed, or passing, ensuring evidence precedes any success claims.

Guides completing development work by verifying tests, presenting structured options for merging, creating a pull request, keeping, or discarding a branch, and cleaning up worktrees.

Executes implementation plans by dispatching a fresh subagent per task and running two-stage reviews for spec compliance and code quality.

Delegates independent debugging tasks to parallel agents with isolated context, preserving the main session for coordination.

Analyzes a codebase with multiple agents and builds an interactive React knowledge graph dashboard for onboarding and visual architecture exploration.

Guides implementing features and bug fixes test-first, enforcing the red-green-refactor cycle with mandatory failure verification.

Creates and maintains persistent markdown planning files that survive session resets by hooking into Claude Code's lifecycle.

Dispatch a code-reviewer subagent to catch issues before they cascade, with guidance on when to request review and how to act on feedback.

Guides technical verification of code review feedback before implementation, emphasizing reasoned pushback over performative agreement.

Guides a structured root-cause investigation before any fix, covering reproduction, evidence gathering, hypothesis testing, and implementation with failing tests.

Creates isolated git worktrees with smart directory selection and safety verification for feature work.

Scopes code-review blast radius and detects architectural hotspots using Tree-sitter AST analysis and GraphRAG, with an MCP server for graph-based analysis.

Runs a multi-agent academic research pipeline covering systematic review, LaTeX paper writing, peer review, and end-to-end orchestration with integrity gates.

Analyzes workflows to identify inefficiencies, bottlenecks, and optimization opportunities, providing a structured report with recommendations for eliminating, resequencing, parallelizing, and automating steps.

Routes conversations to relevant skills from the library, prioritizing process-oriented skills and user instructions.

Turns messy business process descriptions into structured workflows, classifies each step for automation potential using a GREEN/YELLOW/RED framework, and produces a prioritized automation roadmap with time savings estimates.

Loads an implementation plan, reviews it critically, executes each task with verification, and reports completion, stopping to ask for help when blocked.

Bootstraps the always-loaded rules layer for a new repository: writes a CLAUDE.md skeleton and a workflow.md model-notes rule, and optionally installs a native git pre-commit hook. Skips repos already rendered by the Loam Copier template.

Use when creating new skills, editing existing skills, or verifying skills work before deployment.

Runs a plan file through the Codex CLI as an independent adversarial reviewer, then folds accepted findings back into the plan. Read-only sandbox; Codex never edits.

Runs an interactive weekly review session to assess accomplishments against stated goals, identify missed items, and plan the next week with a structured report and accountability question.

Runs Stanford's STORM pipeline to produce Wikipedia-quality research articles with citations, using Claude models and a search engine API.

Turns a spec or requirements into a detailed, bite-sized implementation plan with exact file paths, code, and test steps for engineers with no codebase context.

Guides collaborative dialogue to turn ideas into approved designs and specs before any implementation begins.

Continuously improves Claude's effectiveness by recognizing patterns, saving memory, creating skills, and refining project knowledge. Use when Claude notices repeated workflows, encounters a problem it solved before, wants to save something for future sessions, needs to create a reusable skill, or when the user asks.

Conducts autonomous multi-source research using a planner/executor architecture and an MCP server, with tools for deep research, quick search, report writing, and source retrieval.

Breaks a plan, spec, or PRD into independently-grabbable issues using tracer-bullet vertical slices, then publishes them to the project issue tracker.

Builds a throwaway prototype to answer a design question, choosing between a runnable terminal app for logic/state questions or multiple UI variations switchable from one route.

Generates opinionated design systems with curated color palettes, font pairings, UI styles, product-type rules, and UX guidelines across multiple tech stacks.

Provides a higher-level map of relevant modules and callers using the project's domain glossary when you're unfamiliar with a code area.

Runs a disciplined debugging loop for hard bugs and performance regressions, covering reproduction, hypothesis testing, instrumentation, fixing, and regression testing.

Provides nine skills for Nature-journal-family academic publishing, covering figure creation, prose polishing, manuscript writing, citation formatting, data availability statements, paper reading, reviewer responses, paper-to-PPT conversion, and academic search via an MCP server.

Turns a process description into a complete Standard Operating Procedure document with numbered steps, decision points, checklists, and troubleshooting guidance.

Runs a structured multi-agent deliberation: four specialist agents write independent position papers, two cross-examiners debate them, and the orchestrator synthesizes a final recommendation with implementation plan and risk register.

Runs the current git diff through the Codex CLI for an independent, read-only second-opinion review, then triages findings back into the session for Claude to apply fixes.

Triage issues through a state machine driven by triage roles, including gathering context, recommending actions, and applying outcomes.

Synthesizes the current conversation and codebase context into a structured PRD and publishes it to the project issue tracker with a triage label.

Writes or updates a HANDOFF.md file in the project root to capture goal, progress, and next steps for a fresh agent to continue in-progress work.

Researches conversation and code context to generate 1-6 targeted clarifying questions when a prompt is vague, then executes the original request.

Guides users through structured decision-making with weighted scoring, criteria analysis, and clear recommendations, including quick and interview modes.

Guides test-driven development with a red-green-refactor loop, emphasizing behavior-focused tests and vertical slicing over horizontal test writing.

Surface and clarify unknowns before prompting, log deviations during implementation, and verify understanding after, using HTML artifacts that pair prompts with outputs.

Generates a structured post-task reflection capturing surprises, patterns, prompt improvements, and gotchas, writing it to a markdown file without modifying project rules.

Recommends the optimal Claude model tier (Opus, Sonnet, or Haiku) for a given task by analyzing reasoning depth, blast radius, domain expertise, output length, and correctness cost, and suggests parallelization opportunities.

Finds architectural friction in a codebase and proposes deep-module refactors to improve testability and AI-navigability, informed by the domain glossary and ADRs.

Iteratively improves a compiled LaTeX paper through two rounds of external LLM review, fix implementation, and recompilation.

Recommends the best skill, agent, or command for a given task by classifying intent and scanning available tools.

Reference guide for evaluating LLM-generated translations between CUDA and OpenMP, covering memory model mapping, kernel launch patterns, shared memory, atomics, and common failure modes.

Verifies that every number, comparison, and scope claim in a research paper matches raw result files, using a fresh cross-model reviewer with no prior context to prevent confirmation bias.

Analyzes evaluation results by requiring a stated hypothesis before examining data, then compares expectations to actual result files to prevent post-hoc rationalization.

Reviews CUDA, OpenMP, and OpenCL code for parallel correctness, covering data races, memory model violations, synchronization bugs, numerical precision issues, and API-specific pitfalls.

Reviews a plan from a prior session by extracting the canonical reference prompt from seed/plan-reviewer-design.md and invoking the plan-reviewer agent with it, surfacing the verdict without auto-applying changes.

Simulates a NeurIPS/SC/ICSE-style peer review with five reviewer personas (HPC, ML, Stats, Reproducibility, Devil's Advocate) that verify every claim against actual result data before submission.

Manages a persistent hypothesis tree in markdown, tracking falsifiable claims with linked evidence, timestamps, and next experiments for multi-step research investigations.

Runs an adversarial, decision-aware review of all session work before committing, checking decision adherence and code maintainability, and applies only user-authorized fixes.