API Connector Builder

Use this when the job is to add a repo-native integration surface, not just a generic HTTP client.

The point is to match the host repository's pattern:

connector layout
config schema
auth model
error handling
test style
registration/discovery wiring

When to Use

"Build a Jira connector for this project"
"Add a Slack provider following the existing pattern"
"Create a new integration for this API"
"Build a plugin that matches the repo's connector style"

Guardrails

do not invent a new integration architecture when the repo already has one
do not start from vendor docs alone; start from existing in-repo connectors first
do not stop at transport code if the repo expects registry wiring, tests, and docs
do not cargo-cult old connectors if the repo has a newer current pattern

Workflow

1. Learn the house style

Inspect at least 2 existing connectors/providers and map:

file layout
abstraction boundaries
config model
retry / pagination conventions
registry hooks
test fixtures and naming

2. Narrow the target integration

Define only the surface the repo actually needs:

auth flow
key entities
core read/write operations
pagination and rate limits
webhook or polling model

3. Build in repo-native layers

Typical slices:

config/schema
client/transport
mapping layer
connector/provider entrypoint
registration
tests

4. Validate against the source pattern

The new connector should look obvious in the codebase, not imported from a different ecosystem.

Reference Shapes

Provider-style

providers/
  existing_provider/
    __init__.py
    provider.py
    config.py

Connector-style

integrations/
  existing/
    client.py
    models.py
    connector.py

TypeScript plugin-style

src/integrations/
  existing/
    index.ts
    client.ts
    types.ts
    test.ts

Quality Checklist

matches an existing in-repo integration pattern
config validation exists
auth and error handling are explicit
pagination/retry behavior follows repo norms
registry/discovery wiring is complete
tests mirror the host repo's style
docs/examples are updated if expected by the repo

backend-patterns
mcp-server-patterns
github-ops

Files1

1 files · 1.0 KB

Select a file to preview

Overall Score

78/100

Grade

B

Good

Safety

92

Quality

78

Clarity

80

Completeness

68

Summary

Guides an AI agent to build new API connectors or integrations by analyzing and matching the target repository's existing integration patterns, architecture, and conventions. The agent learns from 2+ existing connectors, defines the integration scope, implements in repo-native layers, and validates against the source pattern.

Detected Capabilities

File system inspection and pattern analysis (existing connectors)Code generation (connector implementation in target style)Configuration schema definition and validationTest fixture generation matching repo conventionsRegistry and discovery wiring (route registration, plugin discovery)Documentation generation for new integrations

Trigger Keywords

Phrases that MCP clients use to match this skill to user intent.

add api connectorbuild integrationmatch connector patternadd third-party providerrepo-native integrationextend connector system

Use Cases

Add a new third-party API integration (Jira, Slack, etc.) to an existing codebase
Build a connector following an established repository pattern without inventing new architecture
Create a plugin or provider that matches the host project's integration style and conventions
Extend a multi-connector system with consistent auth, error handling, and test coverage

Quality Notes

Clear and well-scoped purpose — focuses specifically on pattern-matching within existing codebases, not generic HTTP clients
Strong guardrails section explicitly prevents common mistakes (inventing architecture, skipping wiring, cargo-culting)
Workflow is logically structured with 4 clear phases that guide agent execution sequentially
Reference shapes provide concrete file layout examples for 3 common patterns (Python provider, Python connector, TypeScript plugin)
Quality checklist is comprehensive and actionable — agent can validate its work against these 7 criteria
Scope is well-bounded: skill assumes repo-native patterns exist and agent should learn from them, not design from scratch
Lack of concrete code examples or command sequences — the skill teaches strategy but not syntax specifics for any language/framework
No explicit guidance on handling edge cases: what if the repo has multiple conflicting patterns? What if no existing connectors exist?
Limited error handling instructions — skill does not describe what to do if pattern inspection fails or the repo structure is non-standard
Related skills list is brief but appropriate; could benefit from links or brief descriptions of how those skills compose with this one

Model: claude-haiku-4-5-20251001Analyzed: Apr 20, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Version History

v1.1

Content updated

2026-04-20

Latest

v1.0

No changelog

2026-04-12

api-connector-builder