NITISH-R-G
UserPortable, git-committed memory infrastructure for AI coding agents — survives switching models, providers, IDEs, and harnesses. Adopts the official MCP memory server; doesn't reinvent it.
Categories
Indexed Skills (96)
agent-handoff
Write an explicit handoff note to .memory/HANDOFF.md when consciously ending a session to switch AI tools, models, providers, or harnesses — a deliberate, richer counterpart to the continuous safety net session-checkpoint provides. Use when the user says they're switching to a different agent/tool/provider, when ending a session that isn't finished, or when explicitly asked to prepare a handoff.
agent-ready-codebase
Prepare a codebase so agentic loops and graphs can actually operate on it effectively — legible (agents can find what needs changing), executable (work starts at near-zero token cost), and verifiable (outcomes can be proven, not just claimed). Use when setting up a new project for heavy agentic development, when agents repeatedly waste turns figuring out project structure, or when reviewing why an agent's self-reported success doesn't match actual outcomes.
agentic-loop-autonomy-ladder
Climb agentic autonomy one rung at a time — turn-based, then goal-based, then time-based, then proactive — rather than jumping straight to unsupervised scheduled agents, since each rung hands off strictly more control and skipping rungs produces doom loops. Use when deciding how much autonomy to give an agent, when setting up a scheduled/recurring agent task, or when an unsupervised loop keeps retrying the same broken approach.
orchestrate-agent-architecture
Designing the agent itself for an Orchestrate-style challenge — real agent loops versus hardcoded workflows, tool boundaries, prompt structure, and the design decisions a judge can actually see in your code. Use when starting to build an AI agent for a hackathon or evaluation, when deciding between a scripted pipeline and an agentic loop, when structuring tools/prompts for an agent, or when reviewing whether an agent design would read as genuinely agentic to a reviewer.
orchestrate-ai-collaboration-transcript
Working with an AI coding assistant in a way that produces a strong, scorable chat transcript — visible planning, explicit constraints, real debugging dialogue, deliberate iteration. Use continuously throughout any session where the transcript itself will be evaluated (HackerRank Orchestrate's AI chat transcript signal, or any process similarly graded on how AI tools were directed rather than only on the output). This is a standing discipline, not a one-time checklist — apply it to how you write every prompt, not just at the end.
orchestrate-checkpoint-resilience
Build checkpoint-and-resume capability into a HackerRank Orchestrate agent's batch processing run, so an API rate limit or crash partway through a full-dataset run doesn't force reprocessing everything from scratch. Use when writing the main loop that processes the full ticket/claim dataset, or after a rate limit or timeout has already forced an expensive full rerun once.
orchestrate-cost-and-ops-metrics
Track and report operational metrics — model calls, token usage, cost estimates, runtime, and rate-limit (TPM/RPM) considerations — for a HackerRank Orchestrate submission, a graded requirement in the multi-modal-review challenge. Use when instrumenting an agent's LLM calls, when preparing final approach documentation, or when the interview is likely to ask "how would this scale" or "what does this cost to run."
orchestrate-dataset-coupling-auditor
Find every place a solution accidentally depends on an incidental property of the sample data — id format, timestamp format, row order, filenames, exact wording. Use before submission, because the graded set differs from your sample in every way the spec does not explicitly fix.
orchestrate-determinism-auditor
Prove output is reproducible, and state precisely where that guarantee stops. Use before submission and whenever output changes between identical runs. Unqualified determinism claims are almost always false.
orchestrate-edge-case-testing
Test a HackerRank Orchestrate agent against its failures and inconsistencies, not just its successes — deliberately inspecting where similar cases get different treatment. Use before submission when the only testing done so far was "run it and see if the output.csv looks reasonable," when comparing how the agent handled two superficially similar tickets/claims, or when preparing concrete edge-case examples to discuss in the AI judge interview.
orchestrate-escalation-design
Design escalation and uncertainty-marking as a first-class, calibrated decision in a HackerRank Orchestrate agent — not a fallback bolted on after the main logic. Directly addresses the published finding that both escalate-everything and respond-to-everything fail. Use when designing the decision boundary between automated response and human escalation, or when reviewing whether escalation logic was designed deliberately or added reactively.
orchestrate-evaluator
Score a whole Orchestrate repository across specification, evidence, generalization, determinism, security, and release readiness — and decide whether it is moving toward the top of the leaderboard. Use at each phase gate and before submission.
orchestrate-evidence-retrieval-expert
Design and defend the evidence column. Use when building retrieval or considering a ranker change. Covers the ceiling analysis that tells you whether a gain is possible at all, and why the fashionable option often loses.
orchestrate-failure-handling
Design failure handling for a HackerRank Orchestrate agent so failures degrade safely instead of silently — logging failed rows, continuing processing when safe, and explicitly marking uncertainty rather than guessing. Use whenever writing the main processing loop that iterates over tickets/claims, when deciding what happens if one row's model call errors or times out, or when reviewing whether a submission's error handling would survive a full test run without one bad row crashing the whole batch.
orchestrate-input-tracing
Trace a single input through every stage of a HackerRank Orchestrate agent pipeline (input loading, context building, model invocation, response parsing, validation, fallback) to verify each stage does what you assume it does. Use as a design self-check right after scaffolding a pipeline, when debugging a specific wrong output, or before trusting an architecture diagram you haven't actually walked through with real data.
orchestrate-input-validation-and-overrides
Validate inputs before they reach a model call (not just outputs after), and use deterministic rule-based overrides for cases where model discretion shouldn't apply — for HackerRank Orchestrate agents or any LLM pipeline handling untrusted structured input. Use when writing the ingestion/input-loading stage of an agent, when deciding whether a decision should be left to the model or forced by a rule, or when designing confidence-based safety gates.
orchestrate-interview-readiness
Preparing for an AI-conducted technical interview scored by evidence-anchored rubrics (HackerRank Chakra-style, or similar) — rehearsing specific, concrete answers instead of general ones, and practicing honest disclosure of your system's limitations. Use before any voice or chat interview where an AI judge scores your answers, when the user mentions interview prep for a hackathon/assessment, or when reviewing whether draft interview answers are specific enough to score well.
orchestrate-justification-quality
Writing agent decision justifications that are scored well — evidence-anchored, specific, calibrated, and honest about uncertainty. Use whenever an agent must explain or justify a decision it made (an escalation, a classification, a refusal), when producing an output file that includes reasoning alongside verdicts, or when reviewing agent output for reasoning quality rather than just correctness.
orchestrate-multi-strategy-evaluation
Compare at least two distinct strategies, prompts, or configurations against HackerRank Orchestrate's sample dataset, and document the reasoning behind the final choice — a graded requirement in the multi-modal-review challenge and strong practice for any Orchestrate challenge. Use when deciding between two implementation approaches (e.g. two prompt versions, single-pass vs. multi-pass classification, different retrieval strategies), or when writing the final approach documentation a submission requires.
orchestrate-multimodal-evidence-grounding
Ground claim-verification decisions in specific, cited visual evidence for HackerRank Orchestrate's multi-modal-review challenge (or any future multi-modal Orchestrate challenge) — mapping each claim verdict back to specific image IDs, classifying severity/risk explicitly, and distinguishing "contradicted" from "not enough information" rather than collapsing them. Use when building the image-to-claim reasoning pipeline, or when writing the claim_status_justification field.
orchestrate-naming-and-structure
Structure a HackerRank Orchestrate codebase with clear separation of concerns and descriptive naming — the specific pattern HackerRank's own advice calls out as scored. Use when scaffolding a new Orchestrate project, when a codebase has accumulated files named "helper.py" or "utils.js", or before submission when reviewing whether a fresh reader (or interviewer) could find the entry point and understand the main flow in under a minute.
orchestrate-phase-gates
The master sequencing skill for HackerRank Orchestrate (or any timeboxed agent-building hackathon) — enforces an ordered set of quality gates from planning through submission, and names which companion skill owns each gate. Use this at the START of any Orchestrate-style challenge, whenever the user mentions HackerRank Orchestrate, an agent-building hackathon, a 24-hour AI agent challenge, or asks "what should I do next" mid-build. Also use when a submission deadline is approaching and you need to know what's still unchecked.
orchestrate-prompt-engineering
Write prompts for a HackerRank Orchestrate agent with the same engineering rigor as code — explicit allowed-output specifications, required-evidence framing, and format requirements, treating the prompt as a reviewable artifact rather than throwaway text. Use whenever writing or revising a system/task prompt for the agent, or when reviewing whether prompts would survive being read by an interviewer as carefully as the code will be.
orchestrate-robustness
Defending an LLM agent against adversarial input — prompt injection, jailbreak attempts, ambiguous edge cases, and malformed model output — as an explicit design phase rather than a bug-fixing afterthought. Use when building any agent that processes untrusted or user-supplied input, when a challenge dataset is described as containing edge cases or injection attempts, or when reviewing an agent for failure modes before submission.
orchestrate-rule-engine-architect
Design a deterministic routing engine that is auditable and injection-immune. Use when choosing between rules and an LLM classifier, and when ordering rule tiers. Includes how to prove no rule is dead or shadowed.
orchestrate-schema-guardrails
Build validation guardrails around every LLM-generated field before it reaches output.csv in a HackerRank Orchestrate submission — schema validation, rejecting unsupported label values, and retry-on-malformed-output. Use this whenever writing the code path that turns a model response into a CSV row, when an agent's output occasionally doesn't match the expected schema, or before finalizing output validation for any Orchestrate challenge (support-agent, multi-modal-review, or future ones).
orchestrate-secrets-and-determinism
Enforce the two hard technical constraints HackerRank Orchestrate submissions are explicitly graded on — secrets only in environment variables (never hardcoded), and deterministic/seeded behavior for anything involving randomness or sampling. Use when writing configuration/setup code, when an agent's output changes between identical runs, or before packaging a submission zip to check for embedded credentials or local absolute paths.
orchestrate-security-auditor
Attack your own submission across injection, unicode evasion, regex denial of service, path traversal, and malformed media. Use before release. Every failure path must degrade to a valid output rather than crash.
orchestrate-self-scoring
Honestly estimating how a HackerRank Orchestrate submission (or similar multi-signal AI evaluation) would score across every rubric dimension before submitting, to find the weakest area while there's still time to fix it. Use before final submission of any Orchestrate-style challenge, or whenever the user asks "how would this score" / "is this ready to submit" / wants a pre-submission quality estimate.
orchestrate-spec-auditor
Verify a submission against the literal text of problem_statement.md rather than your memory of it — every column, every allowed value, every separator, every required artifact. Use before any release, and immediately after any change to output formatting. Catches the class of defect that costs points mechanically, with no judgment call involved.
orchestrate-submission-review
Final pre-submission checklist for a HackerRank Orchestrate (or similar multi-artifact hackathon) submission — packaging, file format compliance, and the mechanical failure modes that lose points for reasons unrelated to your agent's quality. Use in the final phase before submitting, or whenever the user asks to do a final check / final pass before turning something in.
orchestrate-submission-validator
Prove the three submission artifacts are current, consistent, and correspond to the same commit. Use in the final hour, and after any change that touches production code. Catches stale outputs, which is the single most common silent submission defect.
decision-log
Record significant architectural or design decisions to .memory/decisions/ in a consistent, ADR-style format, capturing the alternatives considered and why they were rejected — not just the choice made. Use whenever a non-trivial design or architectural decision is made, especially one with real alternatives that were seriously considered and rejected.
memory-bootstrap
Read a project's persistent memory (.memory/BOOTSTRAP.md, HANDOFF.md, and the latest checkpoint) at the very start of any session, before doing anything else — this is what makes a new agent/harness/provider pick up exactly where the last one left off. Use automatically at the start of every session in a project that has a .memory/ directory, or when a user says "continue where we left off," "pick up from before," or switches from a different AI tool mid-project.
memory-capture
Write meaningful state changes to project memory continuously during work — not batched to session end — so an abrupt session cutoff (credit exhaustion, crash, closed laptop) loses at most a few minutes of work, not the whole session. Use whenever a decision is made, a task's state changes, a bug is found or fixed, or something worth remembering happens — throughout every session, not as a single end-of-session step.
memory-consolidation
Periodically compress and promote memory — rolling old checkpoints into episode summaries, and promoting durable lessons from episodic memory into semantic memory — so the memory store stays useful and fast to read instead of growing indefinitely. Use periodically (e.g. at natural session boundaries, or when .memory/checkpoints/ or .memory/episodes/ has accumulated significantly), not as a one-time setup step.
memory-hygiene
Maintain the health of project memory — archiving stale entries past their useful life, catching and flagging conflicting facts, validating that memory entries are still accurate, and cleaning up redundant checkpoints after consolidation. Use periodically as a maintenance pass (paired with memory-consolidation), when memory-recall surfaces a conflict between two entries, or when project memory has grown large enough that retrieval feels noisy.
memory-recall
Retrieve relevant project memory before acting on a task — checking past decisions, related episodes, and semantic facts so work doesn't contradict or duplicate what's already known, following the read-before-reasoning discipline. Use before starting any non-trivial task, before proposing an architectural approach, or when something in the current task sounds like it might have come up before.
repo-awareness
Feed repository state (recent commits, active branch, open TODOs, recently modified files) into project memory so a new session/agent understands current repo context without re-deriving it from scratch. Use at session start alongside memory-bootstrap, or when project memory's sense of "current state" seems stale relative to the actual repo.
session-checkpoint
Write a small, timestamped snapshot of current state to .memory/checkpoints/ periodically throughout a session (not just at the end), so a session that ends abruptly — credit exhaustion, crash, closed terminal — has a recent, resumable state to bootstrap from. Use after completing a meaningful unit of work, before starting something risky or long-running, and periodically during extended sessions — not only when the user asks to "save" or "checkpoint."
compounding-loop-architecture
Architect multiple agentic loops to compound on each other via a shared file system — artifacts, contracts, and a global log — so one loop's findings can trigger another loop's work automatically, rather than running several isolated, non-communicating loops. Use when running more than one recurring agentic loop in the same project, when loops are duplicating discovery work another loop already did, or when designing the file structure a set of autonomous loops will read from and write to.
graph-node-and-edge-design
Design the nodes, edges, and shared state object for a multi-agent graph — specialized work units, routing between them (straight, conditional, fan-out, fan-in), and an explicit state schema — once loop-vs-graph-decision has confirmed a graph is actually warranted. Use when architecting a multi-agent system, when designing fan-out/fan-in parallelism, or when a graph's "shared state" is vaguely defined instead of an explicit schema.
graph-reviewer-node
Design a dedicated, read-only reviewer node with real authority to reject and route work back, separate from the nodes that produce it — the graph-level equivalent of loop-verifier-design's "don't let an agent self-verify" principle, now backed by academic evidence that orchestration-level (decoupled) verification measurably improves output quality. Use when a multi-agent graph has no explicit review/verification node, when a "reviewer" node exists but can't actually reject or route work, or when designing the conditional edge that decides pass vs. loop-back.
loop-stop-conditions
Design explicit stop conditions and hard bounds for any agentic loop — the difference between a closed loop that converges predictably and an open loop that risks burning budget on confident garbage. Use when writing any loop that runs more than once without a human checking each iteration, when an agent is told to "keep going until it's good," or when a loop has no defined maximum rounds/tokens/time.
loop-verifier-design
Design the verifier for an agentic loop — the evaluation function that decides if output is good enough — since the verifier, not the generating model, is the actual bottleneck determining whether autonomous iteration produces value or expensive garbage. Use when building any loop that iterates without a human checking every step, when an agent is asked to "keep improving X" with no defined target, or when reviewing whether a loop's self-verification is trustworthy.
loop-vs-graph-decision
Decide whether an agentic task should be a single loop or escalated to a multi-node graph, using a concrete 4-question test rather than defaulting to whichever pattern is trendy. Use when designing any agent system, when a "should this be multi-agent" question comes up, when a loop's single prompt is trying to do too many distinct jobs, or when reviewing whether a graph architecture is genuinely justified versus a renamed loop.
academic-plotting
Generates publication-quality figures for ML papers from research context. Given a paper section or description, extracts system components and relationships to generate architecture diagrams via Gemini. Given experiment results or data, auto-selects chart type and generates data-driven figures via matplotlib/seaborn. Use when creating any figure for a conference paper.
adopt
Brownfield onboarding — audits existing project artifacts for template format compliance (not just existence), classifies gaps by impact, and produces a numbered migration plan. Run this when joining an in-progress project or upgrading from an older template version. Distinct from /project-stage-detect (which checks what exists) — this checks whether what exists will actually work with the template's skills.
ara-compiler
Compiles any research input — PDF papers, GitHub repositories, experiment logs, code directories, or raw notes — into a complete Agent-Native Research Artifact (ARA) with cognitive layer (claims, concepts, heuristics), physical layer (configs, code stubs), exploration graph, and grounded evidence. Use when ingesting a paper or codebase into a structured, machine-executable knowledge package, building an ARA from scratch, or converting research outputs into a falsifiable, agent-traversable form.
ara-research-manager
Records research provenance as a post-task epilogue, scanning conversation history at the end of a coding or research session to extract decisions, experiments, dead ends, claims, heuristics, and pivots, and writing them into the ara/ directory with user-vs-AI provenance tags. Use as a session epilogue — never during execution — to maintain a faithful, auditable trace of how a research project actually evolved.
ara-rigor-reviewer
Performs ARA Seal Level 2 semantic epistemic review on Agent-Native Research Artifacts, scoring six dimensions (evidence relevance, falsifiability, scope calibration, argument coherence, exploration integrity, methodological rigor) and producing a constructive, severity-ranked report with a Strong Accept-to-Reject recommendation. Use after Level 1 structural validation passes, when an ARA needs an objective epistemic critique before publication or release.
architecture-decision
Creates an Architecture Decision Record (ADR) documenting a significant technical decision, its context, alternatives considered, and consequences. Every major technical choice should have an ADR.
architecture-review
Validates completeness and consistency of the project architecture against all GDDs. Builds a traceability matrix mapping every GDD technical requirement to ADRs, identifies coverage gaps, detects cross-ADR conflicts, verifies engine compatibility consistency across all decisions, and produces a PASS/CONCERNS/FAIL verdict. The architecture equivalent of /design-review.
art-bible
Guided, section-by-section Art Bible authoring. Creates the visual identity specification that gates all asset production. Run after /brainstorm is approved and before /map-systems or any GDD authoring begins.
asset-audit
Audits game assets for compliance with naming conventions, file size budgets, format standards, and pipeline requirements. Identifies orphaned assets, missing references, and standard violations.
asset-spec
Generate per-asset visual specifications and AI generation prompts from GDDs, level docs, or character profiles. Produces structured spec files and updates the master asset manifest. Run after art bible and GDD/level design are approved, before production begins.
audiocraft-audio-generation
PyTorch library for audio generation including text-to-music (MusicGen) and text-to-sound (AudioGen). Use when you need to generate music from text descriptions, create sound effects, or perform melody-conditioned music generation.
autogpt-agents
Autonomous AI agent platform for building and deploying continuous agents. Use when creating visual workflow agents, deploying persistent autonomous agents, or building complex multi-step AI automation systems.
autoresearch
Orchestrates end-to-end autonomous AI research projects using a two-loop architecture. The inner loop runs rapid experiment iterations with clear optimization targets. The outer loop synthesizes results, identifies patterns, and steers research direction. Routes to domain-specific skills for execution, supports continuous agent operation via Claude Code /loop and OpenClaw heartbeat, and produces research presentations and papers. Use when starting a research project, running autonomous experiments, or managing a multi-hypothesis research effort.
awq-quantization
Activation-aware weight quantization for 4-bit LLM compression with 3x speedup and minimal accuracy loss. Use when deploying large models (7B-70B) on limited GPU memory, when you need faster inference than GPTQ with better accuracy preservation, or for instruction-tuned and multimodal models. MLSys 2024 Best Paper Award winner.
axolotl
Expert guidance for fine-tuning LLMs with Axolotl - YAML configs, 100+ models, LoRA/QLoRA, DPO/KTO/ORPO/GRPO, multimodal support
balance-check
Analyzes game balance data files, formulas, and configuration to identify outliers, broken progressions, degenerate strategies, and economy imbalances. Use after modifying any balance-related data or design. Use when user says 'balance report', 'check game balance', 'run a balance check'.
banner-design
Design banners for social media, ads, website heroes, creative assets, and print. Multiple art direction options with AI-generated visuals. Actions: design, create, generate banner. Platforms: Facebook, Twitter/X, LinkedIn, YouTube, Instagram, Google Display, website hero, print. Styles: minimalist, gradient, bold typography, photo-based, illustrated, geometric, retro, glassmorphism, 3D, neon, duotone, editorial, collage. Uses ui-ux-pro-max, frontend-design, ai-artist, ai-multimodal skills.
blip-2-vision-language
Vision-language pre-training framework bridging frozen image encoders and LLMs. Use when you need image captioning, visual question answering, image-text retrieval, or multimodal chat with state-of-the-art zero-shot performance.
brainstorm
Guided game concept ideation — from zero idea to a structured game concept document. Uses professional studio ideation techniques, player psychology frameworks, and structured creative exploration.
brainstorming-research-ideas
Guides researchers through structured ideation frameworks to discover high-impact research directions. Use when exploring new problem spaces, pivoting between projects, or seeking novel angles on existing work.
bug-report
Creates a structured bug report from a description, or analyzes code to identify potential bugs. Ensures every bug report has full reproduction steps, severity assessment, and context.
bug-triage
Read all open bugs in production/qa/bugs/, re-evaluate priority vs. severity, assign to sprints, surface systemic trends, and produce a triage report. Run at sprint start or when the bug count grows enough to need re-prioritization.
agent-handoff
Write an explicit handoff note to .memory/HANDOFF.md when consciously ending a session to switch AI tools, models, providers, or harnesses — a deliberate, richer counterpart to the continuous safety net session-checkpoint provides. Use when the user says they're switching to a different agent/tool/provider, when ending a session that isn't finished, or when explicitly asked to prepare a handoff.
agent-ready-codebase
Prepare a codebase so agentic loops and graphs can actually operate on it effectively — legible (agents can find what needs changing), executable (work starts at near-zero token cost), and verifiable (outcomes can be proven, not just claimed). Use when setting up a new project for heavy agentic development, when agents repeatedly waste turns figuring out project structure, or when reviewing why an agent's self-reported success doesn't match actual outcomes.
agentic-loop-autonomy-ladder
Climb agentic autonomy one rung at a time — turn-based, then goal-based, then time-based, then proactive — rather than jumping straight to unsupervised scheduled agents, since each rung hands off strictly more control and skipping rungs produces doom loops. Use when deciding how much autonomy to give an agent, when setting up a scheduled/recurring agent task, or when an unsupervised loop keeps retrying the same broken approach.
algorithmic-art
Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.
angular-architect
Generates Angular 17+ standalone components, configures advanced routing with lazy loading and guards, implements NgRx state management, applies RxJS patterns, and optimizes bundle performance. Use when building Angular 17+ applications with standalone components or signals, setting up NgRx stores, establishing RxJS reactive patterns, performance tuning, or writing Angular tests for enterprise apps.
api-designer
Use when designing REST or GraphQL APIs, creating OpenAPI specifications, or planning API architecture. Invoke for resource modeling, versioning strategies, pagination patterns, error handling standards.
architecture-designer
Use when designing new high-level system architecture, reviewing existing designs, or making architectural decisions. Invoke to create architecture diagrams, write Architecture Decision Records (ADRs), evaluate technology trade-offs, design component interactions, and plan for scalability. Use for system design, architecture review, microservices structuring, ADR authoring, scalability planning, and infrastructure pattern selection — distinct from code-level design patterns or database-only design tasks.
ask-matt
Ask which skill or flow fits your situation. A router over the skills in this repo.
atlassian-mcp
Integrates with Atlassian products to manage project tracking and documentation via MCP protocol. Use when querying Jira issues with JQL filters, creating and updating tickets with custom fields, searching or editing Confluence pages with CQL, managing sprints and backlogs, setting up MCP server authentication, syncing documentation, or debugging Atlassian API integrations.
benchmark-and-mms-planner
Plan verification and validation campaigns for simulation codes using manufactured solutions, canonical benchmark problems, grid/time refinement, uncertainty propagation, and pass/fail acceptance criteria. Use when an agent needs to prove a solver, model, or result is trustworthy rather than only plausible.
blueprint
Use when the deliverable is WordPress Playground Blueprint JSON or a Blueprint bundle, including creating, editing, reviewing, validating schema keys, choosing steps/resources, and debugging Blueprint files. For only running or sharing a Playground environment, use wp-playground.
brand
Brand voice, visual identity, messaging frameworks, asset management, brand consistency. Activate for branded content, tone of voice, marketing assets, brand compliance, style guides.
canvas-design
Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.
batch-grill-me
A relentless interview that asks every frontier question at once, round by round.
agents-md
Creates and maintains concise AGENTS.md and CLAUDE.md project instruction files. Use when asked to create AGENTS.md, update AGENTS.md, maintain agent docs, set up CLAUDE.md, document repository agent conventions, or keep coding-agent instructions minimal and reference-backed.
agile-processes
Reference for agile software process frameworks — the Agile Manifesto's actual principles, Extreme Programming (XP) practices, Scrum ceremonies and roles, and Kanban flow — covering what problem each solves and common misapplications. Use this whenever the user asks about sprint planning, standups, backlog management, choosing between Scrum and Kanban, XP practices like pair programming, or is setting up or critiquing a team's process.
api-design
Reference for designing web APIs that are predictable and pleasant to consume — resource naming, versioning strategy, pagination, and error response design. Use this whenever the user is designing a new REST/HTTP API, reviewing an API for consistency, deciding how to version or paginate an endpoint, or designing error response formats.
baml-core
Minimal BAML skill. BAML is a statically-typed, expression-oriented language with first-class LLM functions — TypeScript-like, snake_case methods, etc. Useful for building ai workflows, agents, evals.
baseline-ui
Quickly deslop UI code by fixing spacing, hierarchy, typography, and small layout issues. Use when the interface needs a fast cleanup or polish pass.
blog-writing-guide
Write, review, and improve blog posts for the Sentry engineering blog following Sentry's specific writing standards, voice, and quality bar. Use this skill whenever someone asks to write a blog post, draft a technical article, review blog content, improve a draft, write a product announcement, create an engineering deep-dive, or produce any written content destined for the Sentry blog or developer audience. Also trigger when the user mentions "blog post," "blog draft," "write-up," "announcement post," "engineering post," "deep dive," "postmortem," or asks for help with technical writing for Sentry. Even if the user just says "help me write about [feature/topic]" — if it sounds like it could become a Sentry blog post, use this skill.
brainstorming
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.
brand-guidelines
Write copy following Sentry brand guidelines. Use when writing UI text, error messages, empty states, onboarding flows, 404 pages, documentation, marketing copy, or any user-facing content. Covers both Plain Speech (default) and Sentry Voice tones.
browser-use
Direct browser control via CDP for web interaction: automation, scraping, testing, screenshots, and site/app work.
build-systems-and-dependencies
Reference for build system philosophy (task-based vs. artifact-based, module granularity) and dependency management theory (semantic versioning's real limitations, diamond dependencies, the live-at-head alternative). Use this whenever the user is configuring a build system, debugging a dependency conflict, arguing about module boundaries or build file structure, deciding how to version a library, or asking why a dependency upgrade broke something SemVer said it wouldn't.
cavecrew
Decision guide for delegating to caveman-style subagents. Tells the main thread WHEN to spawn `cavecrew-investigator` (locate code), `cavecrew-builder` (1-2 file edit), or `cavecrew-reviewer` (diff review) instead of doing the work inline or using vanilla `Explore`. Subagent output is caveman-compressed so the tool-result injected back into main context is ~60% smaller — main context lasts longer across long sessions. Trigger: "delegate to subagent", "use cavecrew", "spawn investigator/builder/reviewer", "save context", "compressed agent output".
caveman-commit
Ultra-compressed commit message generator. Cuts noise from commit messages while preserving intent and reasoning. Conventional Commits format. Subject ≤50 chars, body only when "why" isn't obvious. Use when user says "write a commit", "commit message", "generate commit", "/commit", or invokes /caveman-commit. Auto-triggers when staging changes.
caveman-compress
Compress natural language memory files (CLAUDE.md, todos, preferences) into caveman format to save input tokens. Preserves all technical substance, code, URLs, and structure. Compressed version overwrites the original file. Human-readable backup saved as FILE.original.md. Trigger: /caveman-compress FILEPATH or "compress memory file"
caveman-help
Quick-reference card for all caveman modes, skills, and commands. One-shot display, not a persistent mode. Trigger: /caveman-help, "caveman help", "what caveman commands", "how do I use caveman".
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.