IBM

End-to-end workflow to examine and summarize an ado operation — fetch operation and space YAML, summarise configuration, export entities/requests/results to CSV, perform simple analysis, and interpret failures and data quality. Use when the user asks to summarize, analyse, debug, or review an operation; wants insights from measurement data; or provides an operation ID or asks to use --use-latest for the current operation.

Builds a picture of work in an ado project: activity volume, spaces and operations created over time, experiments and operation configs used etc. Use to create a project/context overview report, summarize what the team has been doing in an ado project, report trends across spaces/operations, or to onboard onto an ado project.

End-to-end workflow to examine and summarise an ado discoveryspace — fetch space YAML, describe entity and measurement space structure, assess sampling coverage, export measurement data, and find related resources. Use when the user asks to inspect, summarise, debug, or analyse a discoveryspace; wants to understand dimensions, experiments, or sampling coverage; provides a space ID or asks to use --use-latest for the current space.

Formulates problems for execution with ado by creating discoveryspace and operation YAML files. Guides through experiment selection, space creation, validation, operation configuration, and parameterization. Use when the user wants to create discoveryspace or operation YAML files, configure experiments, set up entity spaces, or formulate research, benchmarking or search problems.

Query ado metadata and measurement data using CLI commands. Use when the user needs to find resources, filter by metadata, retrieve entities and measurements, or get resource schemas. Covers metastore queries (operations, discoveryspaces, samplestores, datacontainers, actuatorconfigurations) and samplestore queries (entities and measurements).

Run ado operations on remote Ray clusters using --remote execution context files. Use when the user wants to create an operation, asks about remote clusters, wants to ship local plugins or data files to a cluster, or asks about execution context YAML files. Also applies proactively when creating an operation if execution context files are present in the workspace.

Review committed changes in the current branch. Use when the user asks to review, audit, or critique a branch — covers code quality, skill quality, bugs, linting issues, and adherence to project guidelines. Produces a structured review report written to a markdown file.

Generate a structured changelog for GitHub release notes from changes since the last release. Use when the user asks to generate release notes, a changelog, or a summary of changes since the last tag/release.

Use this skill when making HTTP requests in fp-go using the ReaderIOResult-based HTTP client (github.com/IBM/fp-go/v2/context/readerioresult/http). Trigger on mentions of fp-go HTTP, MakeClient, MakeGetRequest, MakeRequest, ReadJSON, ReadText, ReadAll, ReadFullResponse, the HTTP request builder (WithURL, WithJSON, WithBearer, WithHeader, WithQueryArg), parallel requests with TraverseArray or TraverseTuple2, or building context-aware, composable HTTP pipelines that propagate errors through the Result monad.

Use this skill when working with lenses and optics in Go using the fp-go library (github.com/IBM/fp-go/v2/optics/lens). Trigger on mentions of lenses, optics, MakeLens, MakeLensRef, MakeLensStrict, lens composition, immutable updates to nested structs, accessing nested data structures, Compose, ComposeRef, ComposeOption, FromNillable, FromNillableRef, Modify, getter/setter patterns, or functional updates to Go structs. Also trigger when the user needs to update deeply nested fields immutably or work with optional fields in struct hierarchies. Also trigger for `// fp-go:Lens` annotation or go generate for lens code generation.

Use this skill when working with logging in fp-go functional pipelines (github.com/IBM/fp-go/v2/logging). Trigger on mentions of logging in monadic contexts, ChainFirstIOK, ChainFirst with logging, side-effect logging, structured logging (SLog), context-embedded loggers, LoggingCallbacks, TapSLog, LogEntryExit, Printf/Logf in IO/ReaderIO/ReaderIOResult, or when the user needs to add logging to functional pipelines without breaking the data flow.

Use this skill when working with the fp-go MCP (Model Context Protocol) server located in github.com/IBM/fp-go/gen/v2. Trigger on mentions of MCP server, fp-go MCP tools, list_skills, use_skill, search_examples, get_example, configuring fp-go for Claude Desktop, or when the user needs to access fp-go examples and skills programmatically. This skill explains how to configure and use the MCP server to access fp-go documentation, examples, and skills.

Guides writing, refactoring, and reviewing fp-go v2 code that uses functional composition via Pipe and Flow. Apply this skill whenever the user asks to write new fp-go code, refactor imperative Go into functional style, explain a Pipe/Flow pipeline, add do-notation (Do/Bind/ApS), use the reader monad, create lenses for struct fields, or generate unit tests for functional pipelines. Trigger on any mention of: Pipe, Flow, reader monad, kleisli, do-notation, Bind, ApS, fp-go pipeline, point-free style, lens composition in Go.

Use this skill when reviewing pull requests for fp-go code (github.com/IBM/fp-go/v2). Trigger on mentions of PR review, code review, pull request validation, fp-go best practices validation, functional programming review, or when the user asks to review changes on a PR branch. This skill validates that changes follow fp-go conventions including data-last composition, point-free style, proper monad usage, lens patterns, and idiomatic functional patterns.

Use this skill whenever writing, reviewing, or refactoring Go code that uses the fp-go library (github.com/IBM/fp-go/v2). Trigger on any mention of fp-go, functional programming in Go, monads in Go, Option/Either/Result types in Go, IOResult, ReaderIOResult, data-last composition, Pipe/Flow, or do-notation with Bind/ApS in Go. Also trigger when the user wants to convert idiomatic Go error handling into functional pipelines, or asks about optics (lens, prism, traversal) in Go.

Expert guidance for generating watsonx Orchestrate native solutions from SOPs or simple prompts. Implements agents, flows, tools, and knowledge bases based on business requirements.

Expert guidance for creating high-level solution architecture documents from business requirements, use cases, or problem statements. Produces three focused documents - business overview, technical architecture, and implementation plan - with sufficient detail for elaboration into detailed SOPs.

Analyzes watsonx Orchestrate (wxO) projects and generates a 3-report documentation set covering the overall solution, agents, and tools/connections/other components with Mermaid diagrams.

Build MCP servers for customer care agents following Watson Orchestrate specifications. Guides agents through tool creation, transaction patterns, authentication, widgets, and context management with strict adherence to reference specifications. Use when creating customer care MCP servers.

Expert guidance for building a Standard Operating Procedure (SOP) from a workflow diagram, Langflow JSON, n8n JSON, BPMN model or workflow description. Focuses on business problem, data requirements, and business logic in plain language.

API spec for pyflow, IBM's LLM-optimized Python DSL for authoring DataStage and StreamSets flows. Its compact surface and compile-time validation offer context efficiency, fast feedback, and correctness guarantees, making it the ideal choice for writing flows from scratch and for editing — bootstrap any structural change (a new source, a join) here before precision-editing the SDK.

Q&A reference for the DataStage parallel engine — parallelism, partitioning theory, APT configuration files, concurrent job execution, restart/recovery, disk/resource tuning, dataset performance, flow optimization (partitioning/sorting/memory), and per-stage semantics. Use for conceptual engine questions and stage property lookups regardless of authoring tool.

Reference for the verbose watsonx.data integration SDK for DataStage (batch) flows, with exhaustive stage and property access. New flows can only be created with pyflow's compact DSL (`di-agent-flow-pyflow`); use this SDK to edit existing flows in place — for what pyflow can't express.

Generates a Markdown bug report for an IBM watsonx.data integration session. User can invoke directly. The agent may propose it (and must wait for explicit acceptance) only after exhausting recovery options on a failure. Skip for non-watsonx.data integration sessions.

Reference for StreamSets Data Collector engines and StreamSets environments — StreamSets environment configuration, StreamSets engine deployment (Docker/Podman), StreamSets job execution, StreamSets engine communication methods (tunneling/direct), StreamSets high availability and failover, StreamSets monitoring and resource management. Use ONLY when the user explicitly mentions StreamSets, Data Collector, or a StreamSets-specific concern.

Deploys, configures, and troubleshoots IBM Cloud Code Engine workloads using the ibmcloud ce CLI. Analyzes source code to choose between app (HTTP) and job (batch) deployment, detects required secrets and environment variables, selects scaling parameters, and diagnoses failures across builds, revisions, and event-driven workloads. Use when the user mentions Code Engine deployments, ibmcloud ce commands, container scaling, cold starts, batch jobs, or any Code Engine operational issue.

Convert amounts between different currencies with current exchange rates

Get personalized travel destination recommendations based on preferences

Get current weather and forecast for any location worldwide

Generate Tekton Pipeline that defines the workflow of the task execution.

Generate the Kubernetes `Secret` and `ServiceAccount` to define the docker-registry data.

Generate Tekton Task that uses Trivy to scan generated container for vulnerabilities.

Use when the user wants to stress-test and document a plan for demo purposes - asks up to 3 focused questions, then produces an HTML planning document and a Markdown summary, and optionally posts both to the originating GitHub issue as a comment. Trigger phrases: grill and share, stress-test this plan, review and publish plan, grill my plan.

Interview the user relentlessly about a plan or design. Use when the user wants to stress-test a plan before building, or uses any 'grill' trigger phrases.

Takes a diagnosis from log-parser and writes a Slack incident post and an action checklist. Use this skill second, after log-parser has run. Also triggers on: "write the Slack post", "I need an incident update", "write up what happened", "give me the status message". Output is copy-paste ready — the engineer should not need to edit it.

Reads raw error logs and an alert message to figure out what broke and why. Use this skill first whenever an engineer pastes logs or says "something broke", "we have an incident", "error rate spiked", or "here are the logs". Run this BEFORE incident-brief-summarizer. Outputs a short diagnosis.

Use when the user wants to update the project lock file and requirements files. Syncs uv.lock with origin/main, regenerates lock, and exports all requirement files, then commits the result.

Step-by-step guidance for contributing a new algorithm stack python package to Algorithm Nexus. It ensures all configuration files are properly created, validates the structure of the required nexus package, and helps classify and add the algorithm stack package as a dependency. Use when users want to create a Nexus package for their python library or add their python library to algorithm nexus.

Use this skill when a user wants to create, publish, or set up a new data product in IBM watsonx.data intelligence (wxdi) / Data Product Hub. Trigger when the user says things like "create a data product", "publish a dataset as a data product", "I want to share this data as a product", "set up a data product for X", "onboard this asset to the catalog as a product", or "build a data product from my data". This skill uses a file-based specification approach where data product definitions are created as JSON/YAML files in the workspace, reviewed and refined iteratively, then batch-submitted to DPH. This enables version control, collaboration, and reusability.

Responsible for creating policies, generating and evaluating test cases, testing policies, and automatically improving them.

IBM Diagrams expert for generating IBM-standard architecture diagrams. Use for: Diagram as Code (Python API), Terraform state file visualization, IBM Cloud components (VPC, compute, network, storage, security, data, AI/Watson, containers), DrawIO output generation, or any IBM architecture diagram creation.