Menu
End-to-end orchestrator that creates a new connector from scratch, reviews the code, activates it in Kibana, tests it via an Agent Builder agent, iterates until quality is met, and delivers a polished result. Use when asked to build, develop, or implement a complete connector.
Based on SOC occupation classification
| name | build-connector |
| description | End-to-end orchestrator that creates a new connector from scratch, reviews the code, activates it in Kibana, tests it via an Agent Builder agent, iterates until quality is met, and delivers a polished result. Use when asked to build, develop, or implement a complete connector. |
| allowed-tools | Bash, Read, Glob, Grep, Write, Edit, Skill |
| argument-hint | ["3rd-party-service-name"] |
This skill orchestrates the full lifecycle of building a new connector for $ARGUMENTS. It chains together multiple skills and performs code review and quality verification between each stage.
This skill depends on skills from other plugins. Before starting, ensure they are loaded:
create-agent and chat-with-agent — from x-pack/platform/plugins/shared/agent_builder/.claude/skills/. Load them by reading the SKILL.md files at **/agent_builder/**/SKILL.md.If these skills are not available when needed (Tasks 6–7), the agent creation and chat testing steps will fail.
Use TaskCreate to create all of the following tasks up front so the user can see the full plan. Set all tasks to pending initially.
Set up dependencies: task 2 is blocked by 1, task 3 by 2, task 4 by 3, and so on sequentially.
Then begin working through the tasks in order.
Mark task 1 as in_progress.
Invoke the create-connector skill with $ARGUMENTS as the argument:
Skill: create-connector
Args: $ARGUMENTS
This runs in a forked context and will generate:
src/platform/packages/shared/kbn-connector-specs/src/specs/)docs/reference/connectors-kibana/)When complete, mark task 1 as completed.
Mark task 2 as in_progress.
Review the files generated in Task 1 using the review-connector skill. Apply its checklist to the connector spec and docs.
List all issues found. If no issues are found, note that the code looks good.
Mark task 2 as completed.
Mark task 3 as in_progress.
If issues were found in Task 2, fix them using the Edit tool. After fixing, re-read the files and verify the fixes are correct.
If the fixes are significant, do another review pass. Repeat the review/edit cycle until you're satisfied with the quality — typically 1-2 iterations.
Mark task 3 as completed.
Mark task 4 as in_progress.
Use AskUserQuestion to ask the user to start Elasticsearch and Kibana:
To test the connector, I need Elasticsearch and Kibana running. Please start them if they aren't already:
yarn es snapshot # in one terminal yarn start # in another terminalLet me know when both are ready.
Wait for the user's confirmation. Once confirmed, verify by running:
src/platform/packages/shared/kbn-connector-specs/.claude/skills/activate-connector/scripts/list_connector_types.sh
If this fails, tell the user Kibana isn't reachable yet and ask them to try again.
Mark task 4 as completed.
Mark task 5 as in_progress.
Invoke the activate-connector skill:
Skill: activate-connector
Args: $ARGUMENTS
This will list available types, ask the user for credentials, and create the connector instance via the Actions API. When agentBuilder:experimentalFeatures is true, the connector's sub-actions become available to agents.
Mark task 5 as completed.
Mark task 6 as in_progress.
Invoke the create-agent skill:
Skill: create-agent
Args: $ARGUMENTS Agent
When the skill asks for tool selection, suggest including all connector tools for the newly activated connector (and no platform tools, to keep the test focused).
Mark task 6 as completed.
Mark task 7 as in_progress.
Invoke the chat-with-agent skill to test the agent. Use the agent ID created in Task 6. The default prompt should be:
Summarize the data available to you through your tools.
Skill: chat-with-agent
Args: <agent-id-from-task-6>
Capture and analyze the full output (reasoning, tool calls, tool results, response).
Mark task 7 as completed.
Mark task 8 as in_progress.
Analyze the chat output from Task 7. Check each criterion:
"status":"failed" (unless the failure is due to auth/credential issues, which are not code problems)If tools failed (tool results contain "status":"failed"):
message field in the tool result.Unknown sub-action: 'name' — the sub-action name is wrong. Verify via the connector spec's actions array.Unexpected parameter — the tool call passes a parameter the sub-action doesn't accept. Fix the action's Zod schema.Input should be 'X' — a parameter value is invalid. Fix the action's input constraints.Mark task 8 as completed and note whether iteration is needed.
Mark task 9 as in_progress.
If Task 8 found code issues:
listTools action to discover actual tool names and schemas:
source "$(git rev-parse --show-toplevel)/scripts/kibana_api_common.sh" && kibana_curl -X POST -H "Content-Type: application/json" \
"$KIBANA_URL/api/actions/connector/<connector_id>/_execute" \
-d '{"params":{"subAction":"listTools","subActionParams":{}}}'
Edit to fix the identified issues/chat-with-agentRepeat this loop up to 3 times. If issues persist after 3 iterations, report the remaining problems to the user and move on.
If Task 8 found NO code issues, skip this task entirely.
Mark task 9 as completed.
Mark task 10 as in_progress.
Do one final review using the review-connector skill. Verify no TODOs/placeholders, consistent naming, no debug artifacts. The review skill will also run docs quality checks (docs-check-style, crosslink-validator, frontmatter-audit, content-type-checker, applies-to-tagging) on any connector docs. Make any final minor fixes if needed.
Mark task 10 as completed.
Mark task 11 as in_progress.
Run one final chat conversation to confirm everything works end-to-end:
Skill: chat-with-agent
Args: <agent-id>
Use a more specific prompt this time, something like:
Search for recent items and give me a detailed summary of what you find.
Verify the agent successfully calls tools, gets results, and produces a useful response.
Mark task 11 as completed.
Mark task 12 as completed.
Tell the user something like the below template, listing the actual file paths that were created or modified during the process:
The $ARGUMENTS connector is ready for manual inspection. Here's what was created:
Files created/modified:
- Connector spec:
src/platform/packages/shared/kbn-connector-specs/src/specs/<name>/...- Documentation:
docs/reference/connectors-kibana/<name>-action-type.mdKibana state:
- Connector created with ID:
<id>- Test agent created with ID:
<id>- Test conversations available in Agent Builder
Next steps:
- Open Kibana and navigate to the Agent Builder to inspect the agent
- Try chatting with the agent in the Kibana UI
- Review the generated code and adjust as needed
- When satisfied, commit the code changes
List the actual file paths that were created or modified during the process.
Register and implement custom workflow steps from an external Kibana plugin using `@kbn/workflows-extensions`. Use when adding or modifying a step type with `registerStepDefinition`, designing input/output/config Zod schemas, implementing `createServerStepDefinition` / `createPublicStepDefinition`, choosing `StepCategory`, building `editorHandlers` (selection / dynamicSchema), wiring `callKibanaApi` / `onCancel`, deciding sync vs async loader registration, updating `APPROVED_STEP_DEFINITIONS`, or reviewing PRs that touch any of these.
Register and implement custom workflow triggers from an external Kibana plugin using `@kbn/workflows-extensions`. Use when adding or modifying an event-driven trigger with `registerTriggerDefinition`, designing `eventSchema` Zod schemas, writing `documentation` and KQL `snippets`, wiring `emitEvent` via request context or `getClient`, choosing sync vs async public loader registration, updating `APPROVED_TRIGGER_DEFINITIONS`, or reviewing PRs that touch any of these. Always ask for the user's plugin id first to locate the correct plugin and file paths.
Register and roll out managed workflows from a Kibana plugin using `@kbn/workflows-extensions` and `@kbn/workflows/managed`. Use when adding or modifying a code-owned workflow definition, `registerManagedWorkflowOwner`, `initManagedWorkflowsClient`, `install` / `uninstall` / `ready`, choosing `lifecycle` / `versionStrategy` / `enablement`, authoring `yaml` vs `yamlTemplate`, space-scoped vs global installs, `getWorkflowStatus`, or `execute`, or reviewing PRs that touch managed workflow definitions or rollout. Always ask for the user's plugin id first to locate the correct plugin and definition file paths.
Implement and quality-check OpenTelemetry metric instrumentation in Kibana code that uses `@kbn/metrics`. Use whenever the user wants to add, change, or review OTel metrics — including any call to `metrics.getMeter`, `meter.createCounter`/`createUpDownCounter`/`createGauge`/`createHistogram`/`createObservable*`/`addBatchObservableCallback`, edits to `kibana.yml` `telemetry.metrics` config, or questions like "is this metric well-designed?", "what should I name this counter?", or "which instrument type is right here?". Trigger this skill even when the user does not say "OTel" or "OpenTelemetry" but is clearly adding observability to Kibana server code and already knows what they want to measure.
Primary guided playbook for Elasticsearch search in Kibana Agent Builder: intent → data → mapping → Dev Tools API snippets (SENSE), with one question at a time. Load this skill whenever the user wants to learn Elasticsearch search, get started, begin building, take first steps, onboard, follow a walkthrough or tutorial, go from zero to a working query, or get structured help setting up indices and search — including casual openers like hi, help, getting started, new to Elasticsearch, how do I build search, or I want to try search. Use when they need end-to-end onboarding, not a single narrow API answer. If they only ask what they can build with Elastic (exploration without the full playbook), prefer invoking /use-case-library first; you can still load this skill afterward for the guided build.
Topic-driven, hands-on Elasticsearch tutorial flow that runs in Kibana Dev Console. Use whenever the user says "walk me through", "give me a tutorial for", "teach me", "show me how X works", "tutorial on", or similar topical learning intent — and they are NOT asking you to build their real, specific use case. Topics are open-ended: any Elasticsearch / Kibana search concept the user names (e.g. mappings, analyzers, bool queries, semantic_text, kNN, RRF, aggregations, ingest pipelines, reranking, data streams, ES|QL). Tutorials use sample data on isolated resources, present every step as a SENSE snippet to run in Dev Tools, and end with cleanup plus pointers to docs and the onboarding / pattern skills.