samber/developer-platform-skills / skills/api-versioning-policy
api-versioning-policy
VerifiedDefine the versioning and deprecation policy for an API - version scheme choice (URI path, header, date-based account-pinned, or deliberate no-versioning), a written breaking-change definition, deprecation notice windows by audience, sunset communication (RFC 9745 Deprecation and RFC 8594 Sunset headers), enforcement at the sunset date (fall-forward vs hard cutoff), and breaking-change governance, with REST version-and-sunset and GraphQL continuous schema evolution treated as separate policies. Use whenever the user mentions API versioning, /v2, breaking changes, deprecation, sunset dates, or migration windows - even if they never say "versioning policy". Client SDK versioning is plain SemVer and belongs to samber/developer-platform-skills@sdk-portfolio-strategy.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 26.2 KB |
| evals/evals.json | config | 32.0 KB |
| references/notice-period-benchmarks.md | markdown | 6.5 KB |
| references/policy-document-template.md | markdown | 4.6 KB |
| references/versioning-case-studies.md | markdown | 8.5 KB |
evals/evals.json
View on GitHub{
"skill_name": "api-versioning-policy",
"evals": [
{
"id": 1,
"prompt": "We're Ledgerbird, a B2B payments-reconciliation SaaS. Our REST API has 40 integrators, all partners under signed contracts with named technical contacts. We shipped exactly one breaking change in the past year, and we have another one queued that has to land by end of Q1 - that's the forcing function. The platform team is 3 engineers and there's no per-account configuration infrastructure today. Our CTO came back from a conference sold on Stripe's versioning: date-stamped versions with each account pinned to the version it first used, forever. He wants me to write our versioning and deprecation policy around that model. Draft the policy - scheme, notice terms, the works. This is meant to be our standing policy for years.",
"expected_output": "A policy recommendation that argues against account-pinned date versioning for this team, recommends the URI-path default with an explicit efficiency ranking, sets partner notice terms in the contract, and presents candidate policy bundles rather than one answer.",
"files": [],
"expectations": [
"Recommends against adopting date-based account-pinned versioning for this team rather than drafting the policy around it as asked.",
"States the conditions that would justify account-pinned versioning (breaking changes wanted many times a year plus a long tail of integrators that cannot be forced to migrate) and observes that neither holds for Ledgerbird.",
"Describes account-pinning's ongoing engineering cost as a chain of per-breaking-change compatibility/transformer modules that must be maintained indefinitely.",
"Recommends URI path major versioning (/v1-style) as the appropriate scheme for this case.",
"States a ranking of scheme options in terms of value per unit of effort explicitly in prose, not merely implied by the order options are listed in.",
"Uses the hard end-of-Q1 deadline for the queued breaking change as an argument favoring the low-machinery scheme.",
"States that unversioned access must never be allowed as a fallback path once versioning ships.",
"Notes that removing an unversioned access path later is itself a breaking change.",
"Places the notice-period commitment for the 40 contracted partners in the contract or SLA rather than only on a public policy page.",
"Caps concurrently supported versions at 2-3 active.",
"Presents two or more coherent candidate policy bundles with trade-offs and names a recommendation, rather than a single take-it-or-leave-it policy.",
"Includes a standing health metric: breaking-change frequency above roughly two per year signals the scheme or compatibility discipline is wrong."
]
},
{
"id": 2,
"prompt": "I'm the API PM at Quillhaven, a document-workflow platform. Our public GraphQL API has about 900 registered apps. We're cleaning house: the next release marks 14 legacy fields with @deprecated, and the plan I've written schedules their deletion 90 days after that release ships - the directive shows up in every client's tooling, so everyone gets a full quarter of warning. Legal wants a written deprecation policy they can point at. Can you review my plan and write the policy?",
"expected_output": "A review that rejects calendar-based field deletion, explains @deprecated is a signal not a removal mechanism, and a continuous-evolution policy with a written field-rollover strategy gated on per-field usage telemetry.",
"files": [],
"expectations": [
"States that the @deprecated directive is a documentation and tooling signal, not a removal mechanism.",
"Rejects the fixed 90-day calendar deletion: removal is gated on usage telemetry showing zero (or a consciously accepted residue of) real consumers, never on a date passing.",
"Applies the deprecation and removal process field-by-field rather than version-by-version.",
"Writes down a field-rollover strategy as an explicit sequence: deprecation marker, then per-field usage monitoring, then removal only at zero observed consumers.",
"Requires each @deprecated reason string to name the replacement field.",
"Identifies continuous schema evolution (one continuously live schema, additive changes) as GraphQL's default policy, not a versioned v1/v2 endpoint model.",
"Does not propose introducing versioned GraphQL endpoints as the fix; if date-versioned GraphQL is mentioned at all it is framed as a documented exception for platforms wanting one unified versioning story, not the default.",
"Keeps a written breaking-change definition applied at the field level as part of the policy.",
"States that relying on the directive appearing in client tooling is insufficient and pairs it with at least one channel that reaches humans (changelog, dashboard notice, targeted outreach to apps still querying the deprecated fields).",
"Recommends measuring traffic on each deprecated field before its removal decision.",
"Recommends targeted communication to the specific apps still using the deprecated fields, not only a broadcast announcement.",
"Requires field removals to pass the same breaking-change approval/governance step as any other breaking change."
]
},
{
"id": 3,
"prompt": "Trackpole makes a fitness-data API. Two kinds of consumers: about 200 third-party iOS and Android apps that embed our endpoints (public, self-serve signup), and 9 internal services owned by other teams here. I'm writing our first deprecation policy and I've drafted one line: 'Any version is supported for 6 months after deprecation, for all consumers.' For context, our main competitor gives 3 months, so we're already twice as generous. Also flagging: sales asked whether 'supported for 6 months' means from the version's release or from the deprecation email - I told them it doesn't really matter as long as we're consistent. Can you finalize the policy?",
"expected_output": "A policy that raises the public window to at least 24 months because consumers ship mobile apps, replaces the internal notice period with contract testing, defines the clock start explicitly, and treats published dates as firm commitments.",
"files": [],
"expectations": [
"Rejects the 6-month window as below the floor for a fully public API.",
"States a floor of at least 12 months of deprecation notice for fully public APIs.",
"Raises the recommendation to at least 24 months specifically because Trackpole's consumers ship mobile apps.",
"Gives the reason for the 24-month floor: app-store update cycles and end-user update lag are slow and outside the provider's control.",
"Does not accept the competitor's 3-month window as a justification or benchmark for the number.",
"Replaces the notice period for the 9 internal services with consumer-driven contract testing and coordinated deploys rather than applying the same window to them.",
"Explains why internal consumers differ: a notice period compensates for being unable to coordinate with consumers directly, and internal teams can coordinate.",
"Corrects the 'it doesn't really matter' position: the policy must define exactly when the support clock starts (version release, next version's release, or deprecation announcement).",
"Notes that the clock-start choice moves real dates by months and that ambiguity there turns into support disputes, citing the pattern where a guarantee's clock starts only when the next version ships.",
"Cites external benchmark figures as floors ('at least X months'), never as exact values to copy.",
"Treats published sunset dates as firm commitments and tracks slipped dates with a target of zero.",
"Warns that repeatedly slipping sunset dates teaches integrators to ignore all future dates."
]
},
{
"id": 4,
"prompt": "Meridian Parts runs a B2B auto-parts catalog API - REST, /v1 and /v2 both live. The v1 sunset is scheduled for October. Our head of support is adamant: no customer should ever see an error because of the sunset. So the plan is that from October, any call to a /v1 path gets transparently routed to the /v2 handler - same request, new logic, no error, nobody's integration 'breaks'. I need you to write the enforcement section of our deprecation policy around this, plus whatever else that section needs.",
"expected_output": "An enforcement section that rejects silent rerouting to the newer version, recommends a hard cutoff with a descriptive 410 response and successor link as the default, and documents any fall-forward loudly while noting documentation alone is not noticed.",
"files": [],
"expectations": [
"Warns that silently rerouting retired-version calls keeps apps running while their behavior changes underneath them - a silent-drift failure, not a safe outcome.",
"Recommends a hard cutoff as the default enforcement style at the sunset date.",
"Specifies that the retired version should return a clear, described error rather than silence or connection drops.",
"Recommends a grace period after the sunset date returning 410 Gone so callers get a diagnosable error.",
"Includes a machine-findable pointer to the replacement version (successor-version link relation or equivalent link in the error body).",
"Points out that routing /v1 requests into the /v2 handler sends callers onto an incompatible contract - the plan delivers the breaking change silently; where fall-forward exists as a documented practice it routes to the oldest still-accessible version, not the newest.",
"If a fall-forward style is retained at all, requires it to be documented loudly and states that documented is not the same as noticed - documented silent rerouting still generates persistent complaints about behavior drift.",
"States the chosen enforcement style must be written into the policy, and that if enforcement differs per API surface, both styles must be written down.",
"Frames deprecation as staged (announce, deprecate, sunset, removal) rather than a single October event.",
"Recommends shipping a Deprecation header on v1 responses ahead of the sunset, noting it can ship before or independently of the sunset date and changes no behavior.",
"Recommends a Sunset header carrying the firm retirement timestamp on the deprecated version's responses only.",
"Requires migration support (migration guide, tooling where feasible, support channel) as part of the plan - announcing the sunset and leaving integrators to figure it out is named as a failure mode, not a middle ground."
]
},
{
"id": 5,
"prompt": "I'm a platform engineer at Corvid Analytics. We're deprecating our v2 reporting API - it's public, and about 3,000 API keys have called it this year. My proposal to the team: we add the Sunset HTTP header to all v2 responses with a date 14 months out. That makes us RFC-compliant, every client gets the signal on literally every call, and after the date we're covered. My tech lead asked me to get a second opinion on the communication plan before we ship it. What should the plan be?",
"expected_output": "A communication plan that rejects headers-only signaling, sequences Deprecation before Sunset with correct RFC standing for each, adds successor links and OpenAPI marking, pairs headers with human channels and targeted outreach, and measures traffic response per channel.",
"files": [],
"expectations": [
"Rejects headers-only communication as a named failure mode - shipping the header does not mean anyone was reached.",
"States the reason: most integrators' tooling does not surface these headers, so a header-only plan satisfies the RFC while reaching no one.",
"Distinguishes the two headers' roles: a Deprecation signal that deprecation is coming or here, and a Sunset header carrying the exact timestamp the version stops responding.",
"Identifies the Deprecation header with RFC 9745 and notes it can ship before any sunset date exists and changes no behavior.",
"Identifies the Sunset header with RFC 8594 and notes that RFC is Informational rather than Standards Track, citing it accordingly.",
"Scopes the Sunset header to the deprecated version's responses only.",
"Adds a successor-version link relation so tooling can find the replacement without scraping prose.",
"Marks the deprecated operations with deprecated: true in the OpenAPI document so docs and codegen surface it.",
"Pairs the headers with at least one channel that reaches humans: changelog, developer-dashboard banner, email, or in-response warnings.",
"Recommends targeted outreach at the accounts still calling the deprecated version (or warnings embedded in API responses, which reach exactly the affected callers) rather than only a mass announcement.",
"Requires owning the migration: a migration guide with concrete steps and a support channel, not just the announcement.",
"Recommends tracking deprecated-version traffic share after each communication wave to learn which channels actually reach integrators, treating a flat line after an email blast as evidence the channel failed.",
"Structures the deprecation as staged (announce, deprecate, sunset, removal) instead of jumping from announcement to removal."
]
},
{
"id": 6,
"prompt": "Two of my senior engineers at Bramblewick (HR software, public REST API) have been arguing for a week and I need a ruling plus written rules so this stops recurring. Dispute 1: we want to add a 'contractor' value to the employment_type enum and add a benefits_class field to the employee response - Priya says both need a /v3, Marcus says neither does. Dispute 2: Marcus wants to rename the 'dept' query parameter to 'department' and says it's fine to just ship it since the old name was ugly. And one more thing: our security lead says we don't need to write anything about security patches into the policy because obviously we'd patch any version if there's a CVE - everyone understands that. Please settle the disputes and write the breaking-change section of our policy.",
"expected_output": "A written two-list breaking-change definition that resolves the enum question via declared open enums, classifies the rename as breaking, writes the security exception down narrowly, and declares what is not contractual.",
"files": [],
"expectations": [
"Produces a written two-list definition (breaking vs non-breaking) as policy text, not just case-by-case rulings on the two disputes.",
"Classifies adding the benefits_class response field as non-breaking, shippable into the current version.",
"Classifies adding new optional request parameters as non-breaking in the written list.",
"Classifies renaming the dept query parameter as a breaking change requiring a new version - rejects shipping the rename in place.",
"Resolves the enum dispute with the open-enum device: declare explicitly which enum fields may grow new values without a version bump.",
"States the open-enum rationale: it shifts tolerance onto callers and cuts version churn, as a documented backward-compatible carve-out.",
"Classifies removing an enum value as breaking in the written list.",
"Rejects the unwritten security understanding: the policy must contain a written, narrowly scoped exception reserving the right to patch any version for critical security or privacy issues.",
"Declares what is explicitly not contractual (such as message text, ordering, or timing), reflecting that with enough users every observable behavior gets depended on.",
"States that without a published definition every dispute becomes a judgment call - which is exactly what happened here - so the definition must be published.",
"Includes the operational health metric: needing breaking changes more than roughly twice a year signals the scheme or compatibility discipline is wrong.",
"Classifies changing the status code or content type for the same scenario as breaking in the written list.",
"Classifies changes to the length or format of opaque strings (such as ID prefixes) as non-breaking in the written list."
]
},
{
"id": 7,
"prompt": "Ostrafin is a 12-person fintech startup with one public REST API. Two things on my plate. First: our new VP Eng wants us to stand up an API governance council with a written charter, design-review rotations, and a full compatibility guideline document 'like Google runs' before we ship anything else this quarter. Second: we announced 12 months ago that v1 sunsets on March 1 - that's six weeks out - and our dashboard shows 14% of API traffic is still on v1, spread across 31 accounts. Ops wants to flip the kill switch on March 1 sharp, since we honored the full window. What should I do on both fronts?",
"expected_output": "Advice that scales governance down to the CI-diff-plus-sign-off floor with later stages named as growth steps, and gates the v1 removal on usage rather than the calendar, with targeted outreach to the 31 accounts and a 410 grace period.",
"files": [],
"expectations": [
"Rejects standing up a Google-scale governance program (council, charter, full guideline document) at a 12-person startup now - governance is staged and grown into, not adopted at the top on day one.",
"Recommends the governance floor: an automated breaking-change diff or linter wired into CI plus named-engineer sign-off on anything flagged.",
"Names a specific breaking-change diff/lint tool class for the CI gate (such as oasdiff, Spectral, or Zally).",
"Positions a review board with a written charter as a later stage, appropriate once the API surface outgrows one reviewer.",
"States the invariant that holds at every governance stage: no breaking change ships without the governance layer's approval.",
"Treats the 14% of traffic still on v1 as evidence migration is incomplete: version removal is gated on observed usage, never on the calendar window elapsing.",
"States that the announced window elapsing proves nothing about who actually migrated.",
"Recommends targeted outreach to the 31 accounts still calling v1 (direct email or in-response warnings) during the remaining six weeks.",
"Recommends watching deprecated-version traffic share after each outreach wave to see whether the channel worked.",
"Addresses date integrity rather than casually moving March 1: repeated slippage teaches integrators that dates are not final, so any adjustment must be handled deliberately, with slipped dates counted against a target of zero.",
"Recommends that enforcement at the sunset date be followed by a grace period returning 410 Gone rather than dropping connections.",
"Sets the removal criterion as zero or a consciously accepted residue of real traffic - does not endorse flipping the kill switch on March 1 purely because the window was honored."
]
},
{
"id": 8,
"prompt": "Velodrome Systems here - we run a logistics API versioned with a YYYY-MM header. Three things I want sanity-checked as I formalize our policy. One: requests without the version header currently get the latest version automatically - seems developer-friendly. Two: we marked 2024-03 deprecated eight months ago, but it's still what the interactive docs and new API keys default to - migrating the default mid-year felt risky. Three: marketing wants our SDK version numbers to track the API - SDK 4.x speaks API 2025-04, SDK 5.x speaks the next one - so the developer story stays simple. Write up the scheme section of our versioning policy covering these.",
"expected_output": "A scheme section that requires the version header and errors on unversioned calls, ends the deprecated-and-default contradiction, and decouples SDK SemVer from the API date scheme as a separately written policy.",
"files": [],
"expectations": [
"Flags serving the latest version to header-less requests as unsafe: callers silently receive a new contract on every release instead of a stable one.",
"Recommends requiring the version header and returning an error on unversioned calls rather than applying any default silently.",
"Contrasts the two header-scheme defaults - silently pinning callers to a version versus refusing unversioned calls with an error - and picks the refusal style as safer.",
"Gives the reason: a required version can never drift under a caller silently.",
"Identifies a version being simultaneously deprecated and the default as a named failure pattern, not a tolerable interim state.",
"States the cost of deprecated-and-default: the deprecation label loses credibility while new integrators keep being handed the deprecated version.",
"Recommends moving the default for docs and new API keys off 2024-03 onto a current version as a near-term action.",
"Rejects coupling SDK major versions to API version identifiers as the versioning story.",
"States that client SDKs version under plain SemVer, separate from the wire contract's date scheme.",
"Notes the SDK major-bump trigger is stricter than the API's version rule, because a library's compiled surface breaks in ways a tolerant HTTP caller does not.",
"Recommends writing the SDK versioning policy as its own separate policy rather than folding it into this document.",
"Notes that later removing the unversioned (header-less) access path is itself a breaking change that needs its own notice and communication."
]
}
],
"trigger_queries": [
{ "query": "Write a versioning and deprecation policy for our public REST API - we've never had one", "should_trigger": true },
{ "query": "We're retiring /v1 next spring, plan the sunset timeline and what happens to callers who never migrate", "should_trigger": true },
{ "query": "Should we put the API version in the URL path or in a header?", "should_trigger": true },
{ "query": "Is adding a new field to an API response a breaking change?", "should_trigger": true },
{ "query": "How much notice do we owe integrators before killing an old API version?", "should_trigger": true },
{ "query": "Our CTO wants Stripe-style date-based API versioning, talk me through whether we should", "should_trigger": true },
{ "query": "What should happen when someone calls an endpoint we sunset last month?", "should_trigger": true },
{ "query": "Set up a review process so breaking API changes can't ship without sign-off", "should_trigger": true },
{ "query": "We marked a bunch of GraphQL fields @deprecated - when can we actually delete them?", "should_trigger": true },
{ "query": "how long should we keep old api versions alive", "should_trigger": true },
{ "query": "customers are still calling v1, when can we finally shut it down", "should_trigger": true },
{ "query": "Is adding a Sunset header to our deprecated endpoints enough to cover us?", "should_trigger": true },
{ "query": "our integrators ship mobile apps and update slowly - how long should the migration window be?", "should_trigger": true },
{ "query": "Does this change need a /v2 or can it ship into v1?", "should_trigger": true },
{ "query": "Write down what counts as a breaking change for our API so we stop debating it every sprint", "should_trigger": true },
{ "query": "Shopify does quarterly API versions - should we copy that cadence?", "should_trigger": true },
{ "query": "our api has no version anywhere, is that a problem we need to fix", "should_trigger": true },
{ "query": "What's a reasonable number of API versions to support at the same time?", "should_trigger": true },
{ "query": "should adding a new enum value force a new API version", "should_trigger": true },
{ "query": "We promise 12 months of support per version - when does that clock actually start ticking?", "should_trigger": true },
{ "query": "Design the communication plan for retiring our legacy endpoints", "should_trigger": true },
{ "query": "Fall-forward or hard cutoff when an API version expires?", "should_trigger": true },
{ "query": "do internal microservice APIs need deprecation windows too", "should_trigger": true },
{ "query": "A colleague says versioning APIs violates REST principles and we shouldn't do it - is he right?", "should_trigger": true },
{ "query": "What HTTP headers exist for announcing an endpoint is going away?", "should_trigger": true },
{ "query": "we keep postponing the shutdown date for our old API version, is that a problem", "should_trigger": true },
{ "query": "Draft the outreach to developers still calling the deprecated version", "should_trigger": true },
{ "query": "Our GraphQL API - version it like REST or let the schema evolve continuously?", "should_trigger": true },
{ "query": "The old endpoints die in March. What do we owe the people still on them?", "should_trigger": true },
{ "query": "How do we avoid a Twitter-style API shutdown disaster?", "should_trigger": true },
{ "query": "we need to change a response field's type - walk me through doing that properly", "should_trigger": true },
{ "query": "put together the rules for when engineers are allowed to remove API endpoints", "should_trigger": true },
{ "query": "What does Hyrum's Law mean for what we can safely change in our API?", "should_trigger": true },
{ "query": "date-pinned accounts like Stripe versus a plain /v2 - which fits us?", "should_trigger": true },
{ "query": "we're a two-person startup, do we actually need an API versioning policy yet?", "should_trigger": true },
{ "query": "Our enterprise customers say 6 months isn't enough to migrate off v2 - are they right?", "should_trigger": true },
{ "query": "write the policy for how long each API version stays supported and what happens after", "should_trigger": true },
{ "query": "Should requests without a version header get the latest version or an error?", "should_trigger": true },
{ "query": "410 or 404 when we remove endpoints for good?", "should_trigger": true },
{ "query": "how many months notice before an API sunset is considered standard", "should_trigger": true },
{ "query": "Our deprecated version is still the default for new signups - how bad is that?", "should_trigger": true },
{ "query": "sketch a plan to move everyone off our unversioned endpoints", "should_trigger": true },
{ "query": "What machinery do we need to publish and actually honor API retirement dates?", "should_trigger": true },
{ "query": "My PM asked if we can silently upgrade old API callers to the new version at sunset", "should_trigger": true },
{ "query": "define which API changes need a major version bump versus just shipping", "should_trigger": true },
{ "query": "We ship breaking changes roughly monthly and integrators are furious - fix our approach", "should_trigger": true },
{ "query": "when is it safe to delete a deprecated GraphQL field", "should_trigger": true },
{ "query": "Which languages should get official SDKs first, and in what order?", "should_trigger": false },
{ "query": "When should we bump the major version of our Python client library?", "should_trigger": false },
{ "query": "Set up buf breaking-change checks for our proto files", "should_trigger": false },
{ "query": "Design the pagination and field-naming conventions for our new REST API", "should_trigger": false },
{ "query": "How should our status page communicate a partial outage of the v2 API?", "should_trigger": false },
{ "query": "Write the public postmortem for yesterday's API downtime", "should_trigger": false },
{ "query": "Rotate our customers' API keys with zero downtime", "should_trigger": false },
{ "query": "Design the HMAC signing scheme for our outbound webhooks", "should_trigger": false },
{ "query": "Our webhook deliveries keep failing - design the retry and dead-letter policy", "should_trigger": false },
{ "query": "Pick an error envelope format for our API - RFC 9457 or custom?", "should_trigger": false },
{ "query": "Should rate limits differ between free and enterprise tiers?", "should_trigger": false },
{ "query": "Add idempotency keys so integrators can safely retry POST requests", "should_trigger": false },
{ "query": "Design a sandbox mode with test keys and magic test values", "should_trigger": false },
{ "query": "Audit our API reference for missing response codes and stale examples", "should_trigger": false },
{ "query": "Should we add a GraphQL layer on top of our REST API, and when?", "should_trigger": false },
{ "query": "Design the schema naming and nullability conventions for our public GraphQL API", "should_trigger": false },
{ "query": "Plan the OAuth scopes and consent screen for third-party apps", "should_trigger": false },
{ "query": "How do we force users off an old version of our mobile app?", "should_trigger": false },
{ "query": "Our cluster still uses removed Kubernetes API versions - help me upgrade the manifests", "should_trigger": false },
{ "query": "Plan our migration from Python 2 to Python 3", "should_trigger": false },
{ "query": "What's the support lifecycle for Node.js LTS releases?", "should_trigger": false },
{ "query": "Write a changelog entry announcing our new search endpoint", "should_trigger": false },
{ "query": "Semantic versioning for our npm package - when is it a patch versus a minor?", "should_trigger": false },
{ "query": "Plan the database migration for renaming the users table without downtime", "should_trigger": false },
{ "query": "How should we version our Terraform modules across workspaces?", "should_trigger": false },
{ "query": "Design the schema-evolution contract for our S3 Parquet exports", "should_trigger": false },
{ "query": "Which ETL platforms should we list our source connector on?", "should_trigger": false },
{ "query": "Curate which tools our MCP server should expose to agents", "should_trigger": false },
{ "query": "Review our proposed endpoints for resource naming and status-code correctness", "should_trigger": false },
{ "query": "Draft the listing requirements for third-party apps on our marketplace", "should_trigger": false },
{ "query": "How should we announce scheduled maintenance windows to API consumers?", "should_trigger": false },
{ "query": "Design per-integration request logs with replay for our partners", "should_trigger": false },
{ "query": "Set the revenue share and payout schedule for our app marketplace", "should_trigger": false },
{ "query": "Plan the developer portal onboarding path from signup to first API call", "should_trigger": false },
{ "query": "Should we sunset our free pricing tier?", "should_trigger": false },
{ "query": "Write the end-of-life announcement for our on-prem appliance product", "should_trigger": false },
{ "query": "How do I pin the AWS SDK to a known-good version in our build?", "should_trigger": false },
{ "query": "Configure Spectral rules to enforce our OpenAPI style guide", "should_trigger": false },
{ "query": "Which browser versions should our web app drop support for?", "should_trigger": false },
{ "query": "Handle the breaking changes in the React 19 upgrade for our frontend", "should_trigger": false },
{ "query": "Draft the uptime SLA commitments for our enterprise API customers", "should_trigger": false },
{ "query": "Design feature flags so we can roll risky releases back quickly", "should_trigger": false },
{ "query": "Our GraphQL queries are too expensive - design depth and complexity limits", "should_trigger": false },
{ "query": "Should our gRPC service be public, or should we transcode it to REST?", "should_trigger": false },
{ "query": "Plan the certification program for our integration partners", "should_trigger": false },
{ "query": "Version the prompts in our LLM pipeline so we can roll back regressions", "should_trigger": false },
{ "query": "Sunset our legacy marketing-automation product line", "should_trigger": false }
]
}
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 471k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |