
Check whether claims are adequately supported by cited sources and flag weak or mismatched citations. Use when reviewing research or technical writing.
Review diffs like a senior engineer by checking correctness, architectural fit, style, missing tests, security smells, and migration or operational risk. Use when asked to review a pull request, patch, staged changes, or proposed code edits.
Check rosbag or recorded data replay issues involving topic names, clocks, remaps, timing, and consumer mismatch. Use when replayed data does not reproduce expected behavior.
Audit interfaces for accessibility issues across semantics, keyboard use, focus management, color contrast, labels, and announcements. Use when reviewing or fixing UI accessibility.
Check whether code changes silently broke API contracts, behavior, schemas, or compatibility expectations. Use when reviewing endpoint changes, SDK updates, or public interface diffs.
Draft app titles, descriptions, changelogs, and keyword sets for app-store releases. Use when preparing App Store or Play Store metadata.
Propose lower-cost bill-of-material substitutions while preserving critical requirements, interfaces, and risk constraints. Use when optimizing hardware cost.
Create operational runbooks from tribal knowledge, commands, logs, and recovery steps. Use when recurring incidents lack clean response docs.
Diagnose broken CI pipelines across GitHub Actions, GitLab CI, and similar build systems by inspecting configs, logs, caches, artifacts, and step failures. Use when a pipeline is red or flaky.
Transform one source asset into channel-specific content such as LinkedIn posts, X threads, captions, reel scripts, carousel copy, blog outlines, or newsletters while preserving the core message and voice. Use when adapting content across platforms.
Identify cloud and platform spend hotspots, waste, and likely optimization wins. Use when infrastructure cost is growing or budget pressure exists.
Clean and inspect datasets, check assumptions, compute summary statistics, find anomalies, and translate results into plain-English takeaways with charts when useful. Use for CSV analysis, exploratory data work, KPI checks, or recurring analytical workflows.
Compare two part datasheet revisions and flag electrical, timing, package, or lifecycle changes that matter. Use when components or revisions change.
Review UI changes against spacing, typography, tokens, component usage, and design-system constraints. Use when checking whether frontend work follows system rules.
Turn implementation details into practical documentation such as README updates, setup guides, architecture notes, runbooks, changelogs, and internal reference docs. Use when code exists but docs lag behind or when shipping a feature requires clear documentation.
Interpret firmware and embedded-system logs to narrow likely subsystem faults and next probes. Use when low-level software fails or resets unexpectedly.
Interpret A/B test outcomes, edge cases, segmentation effects, and decision confidence. Use when reviewing experiments or rollout data.
Design staged feature-flag rollouts, guardrails, monitoring, and rollback logic for risky product changes. Use when shipping behind flags or expanding exposure over time.
Structure post-failure analysis from field symptoms, logs, operator notes, and hardware context. Use when investigating failures seen outside the lab.
Trace confusing client-side state bugs involving async effects, caches, stores, routing, forms, or rendering order. Use when frontend behavior is inconsistent or stale.
Organize grant proposal sections, milestones, evaluation plans, and impact framing into a coherent application package. Use when preparing grant materials.
Turn incident timelines, logs, tickets, and chat snippets into a clear postmortem covering impact, detection, root cause, contributing factors, remediation items, and prevention steps. Use after outages, degraded service events, or security incidents.
Identify what documentation is missing by comparing support issues, product behavior, and existing docs. Use when the knowledge base is incomplete or stale.
Map papers by topic, method, findings, gaps, and trends. Use when building a literature review or survey of prior work.
Cluster large log sets into likely issue groups, repeated signatures, and probable root-cause buckets. Use when logs are noisy and need fast pattern extraction.
Convert raw meeting notes, transcripts, or chat logs into decisions, action items, owners, due dates, risks, and follow-up questions. Use after syncs, planning sessions, retros, or stakeholder calls.
Build a full internal or external newsletter from source notes, launches, events, and updates. Use when assembling recurring newsletters.
Add or improve logging, metrics, tracing, dashboards, and alert-ready instrumentation structure. Use when a service lacks visibility or incident triage is too hard.
Identify hot paths, bottlenecks, and likely performance wins from profiles, traces, benchmarks, and code hotspots. Use when an app is slow or a performance budget is being missed.
Convert transcripts into polished show notes, summaries, timestamps, and links. Use when preparing podcast publication materials.
Draft polished client or stakeholder responses to proposals, questions, or requests using source notes and requirements. Use when a fast but professional response is needed.
Review SQL queries, execution plans, schema usage, and indexes to propose safer faster alternatives. Use when a database query is slow or causing load problems.
Plan and execute behavior-preserving refactors by identifying safe structural changes, staging edits incrementally, adding regression coverage, and validating outcomes. Use for legacy cleanup, module extraction, renames, or simplification where behavior must stay the same.
Map unfamiliar repositories by identifying architecture, entry points, setup commands, environment variables, build and test workflows, ownership clues, and common traps. Use when entering a new codebase, preparing onboarding notes, or before making changes in an unfamiliar repo.
Gather and compare sources, extract key claims, note disagreements, flag uncertainty, and produce a concise cited brief. Use for technical research, market scans, literature reviews, or decision memos that need source-backed synthesis.
Structure strong answers for requests for proposal and vendor questionnaires from source material, policies, and product facts. Use when completing formal procurement responses.
Inspect ROS 2 nodes, topics, services, actions, parameters, and live graph structure to explain what is running and how it is connected. Use when observing or validating a live ROS system.
Find unsafe secret handling, config leakage, and risky environment-variable or file-based exposure patterns. Use when auditing configuration and secret hygiene.
Create step-by-step calibration workflows, checks, and validation criteria for sensors and robot subsystems. Use when calibrating or revalidating hardware.
Compare simulation assumptions against real robot behavior, interfaces, timing, and environment differences. Use when code works in sim but fails on hardware.
Turn rough notes into a polished presentation, memo, report, or handout with a clear structure, narrative flow, supporting evidence, and audience-appropriate tone. Use when the user has bullets or fragments and needs a finished doc or deck.
Summarize open-text survey responses into themes, representative quotes, and notable outliers. Use when reviewing survey feedback.
Investigate tests that pass locally but fail in CI by checking timing, order dependence, environment drift, parallelism, fixtures, and isolation. Use when a test is flaky or behaves differently across machines.
Find missing coverage, design useful unit or integration tests, add fixtures or mocks, and explain remaining edge cases. Use when a feature lacks tests, a bug needs regression coverage, or coverage gaps block confidence.
Extract needs, pain points, quotes, and behavioral patterns from user interviews. Use when synthesizing qualitative research.
Turn goals, stakeholders, and open decisions into a tight meeting agenda with required outcomes. Use when planning a focused meeting.
Organize raw commits, merged changes, and unreleased notes into structured versioned changelog entries. Use when maintaining CHANGELOG files or preparing version cut notes.
Generate useful Storybook stories, states, controls, and edge-case examples for UI components. Use when documenting or testing reusable UI pieces.
Define exactly what a product or ops dashboard should show, including metrics, dimensions, filters, and failure modes. Use when planning dashboards or analytics views.
Improve Dockerfiles for image size, caching, security, reproducibility, and multi-stage build hygiene. Use when container builds are slow, bloated, or unsafe.
Write reproducible procedures, controls, materials lists, and validation steps for experiments. Use when formalizing an experiment or study protocol.
Design factory, bench, or end-of-line validation procedures for hardware products. Use when defining manufacturing or production test coverage.
Validate mobile release readiness by checking build artifacts, versioning, store requirements, crash risk, config, and pre-ship blockers. Use before shipping iOS or Android releases.
Run a lightweight personal operating system by reviewing tasks and notes, clustering priorities, drafting weekly plans, surfacing risks, and turning messy inputs into clear next actions. Use for weekly reviews, planning sessions, or personal task triage.
Explain what changed between old and new policy documents and why the differences matter. Use when reviewing policy updates or compliance changes.
Tailor a resume package to a specific role by aligning experience, drafting role-specific bullets, creating a cover letter, outreach note, and interview story bank. Use for job applications, networking outreach, or interview preparation.
Diagnose why a robot software stack will not bring up cleanly across environment, launch, hardware, and runtime dependencies. Use when robot bringup fails or stalls.
Use this skill for ROS 2 workspaces, launch files, runtime graph debugging, topic or service or action decisions, parameter checks, rosbag workflows, TF issues, QoS diagnosis, ros2_control and Nav2 bringup checks, and safe ROS code or config changes. Best for debugging a live ROS graph or understanding a ROS repository from the terminal.
Analyze SLAM and localization logs for mapping drift, sensor mismatch, TF issues, and timing or parameter failures. Use when mapping or localization is unstable.
Improve noisy, weak, or missing alert rules by inspecting SLOs, thresholds, burn-rate logic, and actionability. Use when alerting is too chatty or misses real issues.
Turn large sets of support tickets into issue categories, trends, severity buckets, and ownership hints. Use when support volume needs synthesis.
Explain Terraform plan changes, risk, drift, and likely impact before apply. Use when reviewing infrastructure diffs or plan outputs.
Group user feedback into themes, bugs, requests, sentiment, and confusion points. Use when analyzing feedback corpora.
Generate human-readable release notes from commits, pull requests, tags, and changelog fragments. Use when preparing a release summary for users, customers, or internal teams.
Draft point-by-point responses to reviewer comments using manuscript changes, evidence, and rebuttal structure. Use when responding to peer review.
Design and document API contracts including routes, request and response schemas, validation rules, error envelopes, auth expectations, naming conventions, and examples. Use when creating or revising endpoints, OpenAPI specs, or service interfaces.
Classify support requests, ask the right follow-up questions, choose the correct troubleshooting path, and draft responses in the desired support tone. Use for inbound tickets, bug reports, billing issues, account access problems, or escalation triage.
Turn raw experiment notes into clean, dated, reproducible lab notebook entries. Use when organizing scientific or engineering experiment records.
Map upstream and downstream service dependencies from config, code, environment variables, and network assumptions. Use when understanding system blast radius or ownership.
Reproduce reported bugs, isolate failure conditions, inspect recent changes, test root-cause hypotheses, and propose the smallest safe fix plan. Use for vague "it broke" reports, flaky regressions, failing tests, or production issue investigations.
Review systems for authentication and authorization gaps, secret handling problems, unsafe queries, insecure defaults, data exposure, dependency risk, and abuse paths. Use for code reviews, threat-focused audits, or pre-release security checks.
Review Kubernetes manifests, deployment defaults, probes, resources, security context, and rollout safety. Use when changing or auditing Kubernetes workloads.
Gather code, config, docs, and operational proof points for audits and internal compliance reviews. Use when assembling evidence for controls.
Check whether backup and restore plans are actually restorable, verifiable, and operationally safe. Use when auditing data protection workflows.
Structure scholarship essays from achievements, goals, and personal context into a clear narrative. Use when drafting or refining scholarship essays.
Turn stack traces, tracebacks, and crash logs into likely root causes, suspect files, and next fixes. Use when a runtime failure needs fast explanation from terminal output or logs.
Plan and carry out technical migrations such as dependency upgrades, framework changes, runtime version bumps, routing changes, schema moves, or package reorganizations. Use when a system must transition safely with checklists, compatibility checks, and rollback thinking.
Draft concise investor, advisor, or team updates from raw notes, metrics, and milestones. Use when preparing regular founder or leadership updates.
Estimate scaling risks, bottlenecks, and saturation points before traffic spikes or launches. Use when planning infrastructure growth or event readiness.
Draft community replies, announcements, and moderation actions in an on-brand tone. Use when managing user communities or forums.
Validate power, buses, firmware, interfaces, and low-level sanity checks during hardware bringup. Use when a new robot or board is first being brought online.
Design realistic end-to-end test scenarios from product flows, state transitions, and critical user journeys. Use when building or expanding high-value end-to-end coverage.
Plan safe dependency upgrades by identifying version jumps, breaking changes, migration steps, and validation needs. Use when upgrading libraries, frameworks, or runtimes.
Convert messy sales-call notes into structured CRM-ready entries with next steps, pain points, objections, and deal signals. Use when updating CRM after calls.
Compare vendors or tools using weighted criteria, tradeoffs, risks, and recommendation logic. Use when selecting platforms or partners.
Turn alert streams, incident notes, and partial diagnostics into a clean on-call handoff. Use during shift changes or unresolved incidents.