grok-custom-skills

Performs independent evidence-based scientific and strategic reviews of research proposals, papers, architectures, product concepts, GitHub repositories and strategic initiatives. Acts as a Scientific and Strategic Review Board that challenges assumptions, searches for hidden weaknesses, evaluates scientific rigor strategic alignment novelty and risks, and provides objective recommendations before implementation publication or investment. Use for scientific review, strategic critique, research proposal review, challenge my thinking on science, devil's advocate, independent board review, peer review, architecture review, validate novelty, before publishing paper, investment decision in R&D.

Check your work with a verification subagent that reviews diffs, runs builds and tests, and evaluates correctness. Read this file for instructions. Use when asked to "check work", "verify changes", "self-verify", "/check-work", "/check", "/verify", or "/self-verify".

Run an extremely strict maintainability review for abstraction quality, giant files, and spaghetti-condition growth. Use for a deep code quality audit or an especially harsh maintainability review.

Guides stable API and interface design. Use when designing APIs, module boundaries, or any public interface. Use when creating REST or GraphQL endpoints, defining type contracts between modules, or establishing boundaries between frontend and backend.

Tests in real browsers via Chrome DevTools MCP. Use when building or debugging anything that runs in a browser. Use when you need to inspect the DOM, capture console errors, analyze network requests, profile performance, or verify visual output with real runtime data. Requires the chrome-devtools MCP server to be configured.

Automates CI/CD pipeline setup. Use when setting up or modifying build and deployment pipelines. Use when you need to automate quality gates, configure test runners in CI, or establish deployment strategies.

Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it enters the main branch.

Simplifies code for clarity. Use when refactoring code for clarity without changing behavior. Use when code works but is harder to read, maintain, or extend than it should be. Use when reviewing code that has accumulated unnecessary complexity.

Optimizes agent context setup. Use when starting a new session, when agent output quality degrades, when switching between tasks, or when you need to configure rules files and context for a project.

Guides systematic root-cause debugging. Use when tests fail, builds break, behavior doesn't match expectations, or you encounter any unexpected error. Use when you need a systematic approach to finding and fixing the root cause rather than guessing.

Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when deciding whether to maintain or sunset existing code.

Records decisions and documentation. Use when making architectural decisions, changing public APIs, shipping features, or when you need to record context that future engineers and agents will need to understand the codebase.

Subjects every non-trivial decision to a fresh-context adversarial review before it stands. Use when correctness matters more than speed, when working in unfamiliar code, when stakes are high (production, security-sensitive logic, irreversible operations), or any time a confident output would be cheaper to verify now than to debug later.

Builds production-quality UIs. Use when building or modifying user-facing interfaces. Use when creating components, implementing layouts, managing state, or when the output needs to look and feel production-quality rather than AI-generated.

Structures git workflow practices. Use when making any code change. Use when committing, branching, resolving conflicts, or when you need to organize work across multiple parallel streams.

Refines raw ideas into sharp, actionable concepts through structured divergent and convergent thinking. Use when an idea is still vague, when you need to stress-test assumptions before committing to a plan, or when you want to expand options before converging on one. Triggers on "ideate", "refine this idea", or "stress-test my plan".

Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.

Extracts what the user actually wants instead of what they think they should want. Achieves this through one-question-at-a-time interview until ~95% confidence about the underlying intent. Use when an ask is underspecified ("build me X" without "for whom" or "why now"), when the user explicitly invokes ("interview me", "grill me", "are we sure?", "stress-test my thinking"), or when you catch yourself silently filling in ambiguous requirements before any plan, spec, or code exists.

Instruments code so production behavior is visible and diagnosable. Use when adding logging, metrics, tracing, or alerting. Use when shipping any feature that runs in production and you need evidence it works. Use when production issues are reported but you can't tell what happened from the available data.

Optimizes application performance. Use when performance requirements exist, when you suspect performance regressions, or when Core Web Vitals or load times need improvement. Use when profiling reveals bottlenecks that need fixing.

Breaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.

Hardens code against vulnerabilities. Use when handling user input, authentication, data storage, or external integrations. Use when building any feature that accepts untrusted data, manages user sessions, or interacts with third-party services.

Prepares production launches. Use when preparing to deploy to production. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.

Grounds every implementation decision in official documentation. Use when you want authoritative, source-cited code free from outdated patterns. Use when building with any framework or library where correctness matters.

Creates specs before coding. Use when starting a new project, feature, or significant change and no specification exists yet. Use when requirements are unclear, ambiguous, or only exist as a vague idea.

Drives development with tests. Use when implementing any logic, fixing any bug, or changing any behavior. Use when you need to prove that code works, when a bug report arrives, or when you're about to modify existing functionality.

Discovers and invokes agent skills. Use when starting a session or when you need to discover which skill applies to the current task. This is the meta-skill that governs how all other skills are discovered and invoked.

Grok documentation and configuration help. Use when users ask about setup, configuration, MCP servers, authentication, skills, slash commands, keyboard shortcuts, or any Grok feature. Also use proactively when you detect a user is having trouble with setup or onboarding.

How to use the image_gen and image_edit tool calls in Grok Build: when to build a visual with code instead of generating it, prompt-craft, reference-first handling of real people, factual grounding, and asset-consistency. Load this whenever generating or editing an image is on the table, i.e. when an image_gen or image_edit call is being considered or about to be made. Tool-usage-driven, not triggered by a user merely mentioning images.

Performs OWASP Top 10 static security reviews (SAST) on Python codebases—especially FastAPI, Flask, and Django. Traces user input to dangerous sinks, audits auth and dependencies, and delivers severity-grouped findings with remediation code. Use when asked to security-review Python code, analyze PRs for vulnerabilities, audit web apps, or run /python-owasp-reviewer. Also applies OWASP Agentic Skills Top 10 (AST01–AST10) when reviewing agent workflows, MCP tools, or SKILL.md files.

Use for generating professional editable draw.io diagrams from natural language — architecture, ERD, UML class/sequence, flowcharts, ML models, system designs, network topologies. Trigger on any request for technical visualizations, flow diagrams, or when explaining multi-component systems. Outputs .drawio XML files for opening in draw.io app/desktop. Supports diagram-type presets, color palettes, swimlanes, precise orthogonal layouts, and iterative refinement.

Generate comprehensive Data Cards following Google PAIR Data Cards Playbook specification from a dataset folder plus associated metadata or context YAML. Auto-analyzes files, infers schemas and stats for tabular data, scaffolds all core themes with tables and guidance, produces polished Markdown (convertible to DOCX/PDF). Use for responsible AI documentation of research, healthcare, ML or clinical datasets ahead of reviews, publications or sharing.

Generate interactive single-file HTML infographics with embedded Knowledge Graph Explorer, floating navigation, theme toggle, resolver-backed entity links, and optional matching Markdown companions from RDF Turtle or JSON-LD. RDF is always the source of truth. Use after rdf-kg-generator or on any RDF dataset to create visual exploration artifacts, clinical timeline views, comorbidity graphs, or stakeholder presentations. Supports healthcare-specific rendering for medical entities, patient events, and trial workflows.

Generate standards-compliant RDF Knowledge Graphs (Turtle default, JSON-LD supported) from file-scheme or https URLs, documents, clinical protocols, research articles or pasted text. Uses curated templates for general and healthcare/clinical content with schema.org, SNOMED, RxNorm, LOINC alignment, IRI rules, provenance options and validation. Trigger on requests to generate knowledge graph, RDF from URL or document, JSON-LD extraction, semantic structuring of medical/clinical content, build patient timeline KG or ontology population.

Generate Open Knowledge Format (OKF) bundles for any given repository (GitHub URL or local directory path). Analyzes structure, README, source files, configs and dependencies to produce hierarchical markdown concept documents with YAML frontmatter. Creates portable, versionable knowledge graphs for human/agent consumption and visualization. Trigger on requests like 'generate OKF for this repo', 'create knowledge bundle for github.com/org/repo', 'document this repository in OKF format', 'build OKF concepts from local code checkout'.

Integrated pipeline combining code2prompt (high-quality codebase ingestion + filtering + token management) with OKF concept generation. Includes a custom Jinja2 template optimized for OKF, recommended commands, and full step-by-step workflow to produce rich, compliant Open Knowledge Format knowledge bundles from any repository. Trigger on 'use code2prompt with OKF', 'advanced repo to OKF pipeline', 'generate OKF using code2prompt', or when needing tight integration between structured code context and OKF bundles.