How does this skill prevent production API failures compared to a manual code review?

This skill acts as an automated quality gate in your CI/CD pipeline, performing a deep structural comparison of OpenAPI specs to flag deleted fields, modified parameters, or renamed endpoints that would otherwise crash downstream services.

Which AI agents and development environments are compatible with this skill?

The detector is designed for any AI agent or CI tool that supports OpenAPI 3.x (JSON/YAML) and can execute shell-based logic, including GitHub Actions, GitLab CI, and Jenkins.

Can I configure the skill to only block pull requests for specific types of breaking changes?

Yes, the skill categorizes changes into ERR, WARN, and INFO levels, allowing you to set the detector to only block builds (exit code 1) when critical breaking changes are found while allowing minor additions.

What exactly is included in the purchase of this skill?

Upon purchase, you receive the integrated detection logic, pre-configured reporting templates for changelogs, and the automated guardrail scripts ready to be added to your workflow.

Are there any specific technical requirements or limitations I should be aware of before deploying?

While the skill is highly robust, it requires valid OpenAPI 3.x files to run and cannot resolve external $ref pointers if they are hosted on private servers not accessible during the analysis phase.

API Breaking-Change Detector — CI Guardrail

Example session with this skill installed

Compare openapi-v1.yaml and openapi-v2.yaml. Flag breaking changes and generate all artifacts. The new version removes the 'email' field from the User schema response.

Read your context and instructions
Compiled the api breaking-change detector

Analysis complete. A breaking change was detected in the User schema. All artifacts have been generated.

API Contract Diff — v1.0.0 → v1.1.0

Engine: manual-read
Base: openapi-v1.yaml (v1.0.0)
New: openapi-v2.yaml (v1.1.0)

Summary

Severity	Count	Notes
`ERR`	1	Removed response field in User schema
`WARN`	0	none
`INFO`	0	none

Exit code: 1 — breaking changes detected.

Breaking changes (`ERR`)

GET /users/{id} — Removed response field email from the User schema. This will break clients expecting this property.
- Remediation: Restore the email field or mark it as deprecated if a new field replaces it.

ERR checklist

Category	Result
Deleted endpoint	pass
Modified path parameter	pass
Status code shift	pass
Removed response field	fail
New required request field	pass
Type narrowing	pass
Enum value removal	pass

API_CHANGELOG.md


# API Changelog
## [1.1.0]
### Breaking Changes
- Removed `email` property from `User` response object in `GET /users/{id}`.

diff.json

{
  "schema_version": "1.0",
  "engine": "manual-read",
  "summary": { "err": 1, "warn": 0, "info": 0 },
  "exit_code": 1,
  "breaking": [
    {
      "id": "ERR-001",
      "rule": "removed-response-field",
      "location": "GET /users/{id}",
      "field": "User.email",
      "description": "Removed property 'email' from response.",
      "remediation": "Restore field or start deprecation cycle."
    }
  ],
  "warnings": [],
  "info": [],
  "unchanged": ["POST /users", "GET /health"],
  "err_checklist": {
    "removed_response_field": "fail"
  }
}

Next steps

Review BREAKING_CHANGES.md for full remediation details.
Revert the field removal or update the ignore_file if this is an intentional break.
Run the diff again to verify the fix.

openapi-v1.yaml

Connects securely to your tools. The creator never sees your data.

About this skill

API Breaking-Change Detector is a Claude Code skill for detecting backward-incompatible changes between OpenAPI 3.x specifications. It performs semantic contract diffing on JSON or YAML specs and classifies every difference into three severity levels: ERR (breaking), WARN (non-breaking risk), and INFO (additive or metadata). The skill catches deleted endpoints, modified path parameters, removed response fields, new required request fields, type narrowing, and enum value removal—the exact changes that break existing API clients.

Every run produces a complete artifact set in a single pass: API_CHANGELOG.md, BREAKING_CHANGES.md, diff.json (schema-conformant, with breaking, warnings, and info arrays always present), and—when a deprecation or approved break exists—DEPRECATION_PLAN.md. The skill also walks a seven-category ERR checklist on every run, proving the negative when no breaking changes are found, and explicitly states the CI exit code.

Use cases: pull request gating, contract drift audits, version comparison before release, and automated changelog generation. Compatible with oasdiff, api-governor, and OpenAPI Comparator, or fully functional as a manual-read fallback when no tool is available.

Keywords: OpenAPI breaking change detector, API contract diff, backward compatibility checker, CI/CD API guardrail, semantic diff OpenAPI, contract drift detection, oasdiff skill.

How to use

Skills on Agensi run inside your AI agent. Copy the prompt, paste it into your agent, and it connects to Agensi and installs this skill for you. If a payment is needed, your agent shows it to you first.

Reviews

No reviews yet

Be one of the first to try it. Every listed skill passes our trust checks below.

Security scanned

Passed our 8-point scan before listing

Fresh listing

Recently published to Agensi

Money-back guarantee

Doesn't do what its page promises? You get your money back.

API Breaking-Change Detector — CI Guardrail