This prompt is designed for developer relations engineers, API product managers, and platform teams who need to communicate a specific field-level deprecation to external or internal API consumers. The core job-to-be-done is transforming a technical deprecation decision—often a ticket or an internal spec change—into a structured, empathetic, and actionable communication that minimizes consumer friction, reduces support ticket volume, and provides a clear migration path. The ideal user has already made the decision to deprecate a field and possesses the technical details, such as the field path, the replacement field, and the planned timeline. The prompt requires this context to be provided as structured input.
Prompt
Deprecation Notice Drafting Prompt for API Fields

When to Use This Prompt
Defines the ideal scenario, user, and required context for drafting a consumer-ready API field deprecation notice, and clarifies when this prompt should not be used.
Use this prompt when you have a single, well-defined field or a small, related set of fields to deprecate and you need to draft a notice for a developer blog, an email campaign, or an in-dashboard notification. It is particularly effective when the replacement is straightforward, such as a renamed field or a new enum value. The prompt's value lies in enforcing a consistent structure that includes a clear timeline, a side-by-side migration example, and a tone calibrated for a technical audience. For example, if you are deprecating user.firstName in favor of user.givenName, the prompt will guide the model to generate a notice with a concrete before-and-after code snippet, not just a vague instruction to 'update your code.'
Do not use this prompt for generating full API reference documentation, automated changelogs from a git diff, or internal engineering migration runbooks. It is not designed to analyze a schema diff to discover deprecations; it assumes the deprecation is a known fact. For high-risk or regulated contexts, such as deprecating a field used in financial transactions or healthcare data, the output of this prompt must be treated as a first draft that requires human review for legal and compliance accuracy. The prompt is a communication drafting tool, not a source of truth for the deprecation policy itself. After using this prompt, your next step should be to validate the generated notice against your internal deprecation policy and test the migration example yourself before publishing it to consumers.
Use Case Fit
Where the Deprecation Notice Drafting Prompt works well and where it introduces risk. Use these cards to decide whether this prompt fits your workflow before you integrate it into a developer communications pipeline.
Good Fit: Structured Deprecation Workflows
Use when: you have a formal API lifecycle with defined deprecation windows, replacement fields, and migration guides. The prompt excels at turning structured inputs (field name, timeline, replacement) into consistent, consumer-ready notices. Guardrail: always provide a complete [DEPRECATION_SPEC] with required fields; the prompt cannot invent missing migration steps.
Bad Fit: Undefined Replacement Strategy
Avoid when: the replacement field or migration path is not yet decided. The prompt will hallucinate plausible but incorrect migration examples if forced to draft without a concrete replacement. Guardrail: gate the prompt behind a required [REPLACEMENT_FIELD] input; if null, route to a human drafter instead of generating speculative guidance.
Required Inputs: Structured Deprecation Spec
Risk: incomplete inputs produce notices that mislead consumers about timelines or replacement behavior. Guardrail: enforce a strict [DEPRECATION_SPEC] schema including deprecated_field, replacement_field, sunset_date, migration_notes, and affected_endpoints. Validate all fields are present before invoking the prompt.
Operational Risk: Tone Drift in Developer Comms
What to watch: the model may produce overly casual, apologetic, or defensive language that undermines trust with API consumers. Guardrail: include a [TONE_PROFILE] parameter (e.g., "professional, direct, helpful") and run output through a tone consistency check before publishing. Maintain a library of approved notice examples for few-shot grounding.
Operational Risk: Stale Timeline References
What to watch: generated notices may reference relative dates ("next quarter") that become misleading if the notice is cached, delayed, or republished. Guardrail: require absolute dates in [DEPRECATION_SPEC] and add a post-generation check that all dates are in the future. Flag any relative date language for human review.
Bad Fit: Multi-Service Coordinated Deprecations
Avoid when: a single field deprecation spans multiple services, client SDKs, or documentation surfaces that need coordinated messaging. The prompt handles one notice at a time and cannot ensure cross-service consistency. Guardrail: for coordinated deprecations, use this prompt per service, then run a cross-notice consistency check for conflicting timelines or contradictory replacement guidance.
Copy-Ready Prompt Template
A copy-ready prompt template for drafting consumer-facing API field deprecation notices, with placeholders for the specific field, timeline, and replacement details.
Use the following prompt template to generate a structured, developer-friendly deprecation notice. The template is designed to produce a complete communication that includes the rationale, a clear timeline, a migration path with code examples, and a tone appropriate for maintaining trust with your API consumers. Before using it, gather the specific field path, the deprecated and replacement field names, the sunset date, and any relevant links to migration guides or changelogs.
codeYou are a developer relations engineer for an API platform. Your task is to draft a clear, empathetic, and technically precise deprecation notice for an API field. The notice will be published in a developer changelog and emailed to affected consumers. ### INPUT - **API Name and Version:** [API_NAME_AND_VERSION] - **Deprecated Field Path:** [DEPRECATED_FIELD_PATH] - **Replacement Field Path:** [REPLACEMENT_FIELD_PATH] - **Deprecation Announcement Date:** [ANNOUNCEMENT_DATE] - **Sunset Date (when the field will be removed or start returning errors):** [SUNSET_DATE] - **Reason for Deprecation:** [REASON] - **Link to Migration Guide:** [MIGRATION_GUIDE_URL] - **Link to API Changelog:** [CHANGELOG_URL] ### CONSTRAINTS - Write in a helpful, professional tone. Do not be alarmist. - Clearly state the timeline with specific dates. - Provide a concrete migration example showing the deprecated request/response and the new request/response. - Explicitly state the breaking change date and what happens after that date (e.g., the field will return `null`, be removed, or cause a 400 error). - Include a subject line suitable for an email. - Do not invent features or timelines not provided in the input. ### OUTPUT_SCHEMA { "email_subject": "string", "notice_body": "string (markdown formatted)", "migration_code_example": "string (markdown code block)", "key_dates": [ { "event": "string", "date": "string" } ] }
To adapt this template, replace each square-bracket placeholder with the concrete details from your API change. If the deprecation is non-breaking until the sunset date, ensure the CONSTRAINTS section reflects that by specifying the post-sunset behavior. For high-risk or widely-used fields, add a [CONSUMER_IMPACT_SUMMARY] placeholder and instruct the model to include a section on estimated consumer impact. After generating the notice, always have a human review it for technical accuracy and tone before publication.
Prompt Variables
Each variable must be populated before the prompt is assembled and sent. Missing or malformed inputs will cause the model to hallucinate timelines, skip required sections, or produce a notice that fails the developer experience checks.
| Placeholder | Purpose | Example | Validation Notes |
|---|---|---|---|
[DEPRECATED_FIELD_PATH] | Fully qualified path to the field being deprecated | data.attributes.legacy_status | Must match a real field in the current API spec. Parse check: valid JSONPath or dot-notation string. Null not allowed. |
[API_VERSION] | Current API version where deprecation is announced | v3 (2025-03-15) | Must match a released or planned version string. Schema check: semver or date-based version format. Null not allowed. |
[SUNSET_DATE] | Date when the deprecated field will be removed or return an error | 2025-09-15 | Must be a future date in ISO 8601 format. Parse check: valid date string. Must be at least 90 days after announcement date per policy. |
[REPLACEMENT_FIELD_PATH] | Path to the replacement field consumers should use instead | data.attributes.status | Must be a valid field path in the same or newer API spec version. Null allowed if no direct replacement exists. If null, [MIGRATION_GUIDANCE] becomes required. |
[MIGRATION_GUIDANCE] | Step-by-step instructions for consumers to adopt the replacement | Update your client to read data.attributes.status instead. The new field uses the same enum values but adds 'archived'. | Required if [REPLACEMENT_FIELD_PATH] is null or if the migration involves behavior changes beyond field renaming. Human approval required before use. |
[AFFECTED_ENDPOINTS] | List of API endpoints that return or accept the deprecated field | GET /v3/items, GET /v3/items/{id}, PATCH /v3/items/{id} | Must be a non-empty list of valid endpoint paths in the current API spec. Schema check: array of strings matching route patterns. Null not allowed. |
[CONSUMER_IMPACT_SCOPE] | Description of which consumer groups are affected and how | All mobile SDK clients on v2.x and earlier; web clients on v3.x are unaffected | Must be a non-empty string describing affected consumers. Human review required to verify completeness against known consumer registry. Null not allowed. |
[COMMUNICATION_CHANNEL] | Channel where the deprecation notice will be published | API changelog, developer email newsletter, in-band Deprecation header | Must be one of the approved channels from the developer communications policy. Enum check: changelog, email, header, dashboard, or webhook. Null not allowed. |
Implementation Harness Notes
How to wire the deprecation notice prompt into a developer communications workflow with validation, review gates, and publication checks.
This prompt is designed to be called from an internal developer portal, API changelog pipeline, or release automation system. The primary integration point is a schema diff event: when a field is marked deprecated: true in an OpenAPI spec or a GraphQL @deprecated directive is added, the system triggers this prompt with the field metadata, deprecation date, replacement guidance, and affected endpoint context. The prompt should not run on every schema change—only on newly detected deprecation annotations to avoid generating duplicate or stale notices.
Wire the prompt into an application harness that performs pre-generation validation and post-generation review. Before calling the model, validate that all required inputs are present: [FIELD_NAME], [API_VERSION], [DEPRECATION_DATE], [REPLACEMENT_GUIDANCE], and [AFFECTED_ENDPOINTS]. If any input is missing or the deprecation date is in the past, abort and log a structured error rather than generating a confusing notice. After generation, run the output through a schema validator that checks for required sections (timeline, replacement, migration example, contact link) and flags missing elements. For high-visibility APIs, route the draft to a human reviewer via a Slack notification or PR draft before publication. Log every generation with the input hash, model version, output, and review status for auditability.
Model choice matters for tone consistency. Use a model with strong instruction-following and developer-documentation fluency—GPT-4o or Claude 3.5 Sonnet are good defaults. Set temperature low (0.1–0.3) to reduce stylistic variance across notices. If your organization maintains a style guide or tone examples, include them in [TONE_EXAMPLES] as few-shot demonstrations. For teams publishing notices across multiple API products, cache the tone examples and brand constraints in a reusable prompt prefix to reduce token waste and improve consistency. Avoid using smaller or older models for this task—they tend to produce either overly casual language or robotic boilerplate that undermines developer trust.
Retry logic should be minimal. If the output fails schema validation, retry once with the validation errors appended to the prompt as [PREVIOUS_ERRORS]. If the second attempt also fails, escalate to a human writer rather than retrying indefinitely. Common failure modes include: omitting the migration code example, using vague timelines like 'soon,' failing to link to the replacement field's documentation, or generating a notice that sounds apologetic rather than informative. Your eval suite should include test cases for each of these failure modes, plus edge cases like fields with no direct replacement, fields deprecated across multiple API versions simultaneously, and fields used in webhook payloads where consumer impact is harder to assess.
For publication, integrate the validated output into your changelog CMS, developer email system, or API status page. If publishing to multiple channels, use the structured output fields ([MIGRATION_EXAMPLE], [TIMELINE], [REPLACEMENT_FIELD]) to format channel-specific versions rather than regenerating the entire notice. Store the generated notice alongside the schema change that triggered it so future audits can trace every deprecation communication back to its source diff. When the deprecation window closes and the field is removed, trigger a follow-up notice using a variant of this prompt with [NOTICE_TYPE] set to removal to close the communication loop with affected consumers.
Expected Output Contract
Fields, format, and validation rules for the deprecation notice generated by the prompt. Use this contract to validate the model output before publishing or routing for human review.
| Field or Element | Type or Format | Required | Validation Rule |
|---|---|---|---|
notice_title | string | Must start with 'Deprecation Notice:' or 'Action Required:'. Length between 10 and 120 characters. | |
api_name | string | Must match a known API name from [API_CATALOG]. Non-empty. No markdown. | |
deprecated_field_path | string | Must be a valid JSONPath or dot-notation path matching the field in [FIELD_LIST]. Must not be empty. | |
effective_date | ISO 8601 date string (YYYY-MM-DD) | Must be a future date. Must parse with Date.parse(). Must be after [CURRENT_DATE]. | |
sunset_date | ISO 8601 date string (YYYY-MM-DD) or null | If provided, must be after effective_date. Null allowed for advisory deprecations without a hard removal date. | |
replacement_guidance | string | Must contain at least one actionable migration step. Must reference a replacement field or endpoint from [REPLACEMENT_MAP] if available. Length >= 50 characters. | |
migration_example | string (code block or plain text) | Must include a before/after code snippet or a clear structural example. Must be syntactically valid for the target language specified in [SDK_LANGUAGE]. | |
consumer_impact_summary | string | Must classify impact as 'breaking', 'non-breaking with action required', or 'advisory'. Must not exceed 300 characters. Must not contain speculative language about consumer behavior. |
Common Failure Modes
What breaks first when drafting deprecation notices with an LLM and how to guard against it.
Missing or Vague Migration Path
What to watch: The model produces a polite deprecation announcement but omits the concrete replacement field, code example, or migration steps. Developers are left with a deadline and no action plan. Guardrail: Require a [REPLACEMENT_FIELD] and [MIGRATION_EXAMPLE] placeholder in the prompt template. Validate the output contains a code block before publishing.
Incorrect or Invented Timeline
What to watch: The model hallucinates a deprecation date, sunset version, or support window that contradicts the actual product roadmap. This creates legal and trust liabilities for the API provider. Guardrail: Inject the exact [DEPRECATION_DATE] and [SUNSET_DATE] from a source of truth (e.g., product database) as non-negotiable input variables. Add a post-generation check that the output dates match the input exactly.
Tone Mismatch for Developer Audience
What to watch: The notice sounds either alarmist ("URGENT BREAKING CHANGE") or dismissively casual ("just a small heads-up"), eroding developer trust. The tone fails to match the actual severity of the change. Guardrail: Include a [SEVERITY_LEVEL] input (e.g., routine, important, critical) with explicit tone instructions for each level. Use a tone eval check: "Does this sound appropriate for a professional API changelog?"
Leakage of Internal-Only Context
What to watch: The model includes internal rationale, Jira ticket references, or engineering trade-off discussions that should not appear in a public-facing developer notice. Guardrail: Use a strict system instruction:
Inconsistent Field Path or Version Formatting
What to watch: The model formats the deprecated field path differently from the organization's API documentation standard (e.g., data.attributes.fieldName vs data/attributes/field_name), causing confusion or broken tooling. Guardrail: Provide a [FIELD_PATH_FORMAT_EXAMPLE] in the prompt showing the exact convention. Validate the output with a regex or structural check against the expected path format.
Omitting Consumer Impact Scope
What to watch: The notice states the field is deprecated but fails to clarify which API versions, endpoints, or client SDKs are affected. Consumers waste time investigating unaffected services. Guardrail: Require structured output sections: Affected Endpoints, Affected Versions, and Unaffected Surface Area. Validate each section is populated and non-empty before publication.
Evaluation Rubric
Score each criterion from 1 (Poor) to 5 (Excellent). A production-ready draft should score 4 or higher on all criteria. Use this rubric to gate the deprecation notice before sending to consumers.
| Criterion | Pass Standard | Failure Signal | Test Method |
|---|---|---|---|
Deprecation Timeline Clarity | Notice includes a specific deprecation date, a sunset date, and a removal date in ISO 8601 format | Vague language like 'soon' or 'in the future'; missing one or more milestone dates | Parse output for date fields; assert all three milestones are present and chronologically ordered |
Replacement Path Completeness | Every deprecated field has a corresponding replacement field or method with a code example in at least one language | Deprecated field listed without a replacement; replacement mentioned but no usage example provided | Extract deprecated field list and replacement mapping; assert 1:1 mapping exists; assert code block is present for each |
Migration Example Executability | Provided code examples compile and run against the target API version without modification | Examples reference removed fields; examples use placeholder values that cannot be replaced; examples are pseudocode | Run examples through a syntax validator for the target language; assert no references to deprecated field names |
Consumer Impact Surface Coverage | Notice identifies all affected client SDKs, API versions, and endpoint paths where the deprecated field appears | Notice omits an SDK variant; notice fails to mention that the field appears in multiple endpoints | Cross-reference deprecated field against OpenAPI spec; assert all paths and SDKs are enumerated in the notice |
Tone and Developer Empathy | Notice acknowledges consumer effort, provides a clear rationale for the change, and avoids blame language | Notice is terse to the point of hostility; rationale is missing or reads as dismissive of consumer impact | Run through a tone classifier; assert empathy score >= 4; assert absence of blame-phrasing patterns |
Migration Window Feasibility | The time between deprecation announcement and removal allows at least one full consumer release cycle based on stated SLAs | Sunset date is less than 30 days from announcement; notice does not reference consumer release cadence | Calculate delta between announcement date and sunset date; assert delta >= stated minimum migration window in days |
Backward Compatibility Statement | Notice explicitly states whether the deprecated field continues to function during the deprecation window and any behavior changes | No mention of whether the field still works; ambiguous language like 'may stop working' without specifics | Search output for compatibility guarantee language; assert a boolean statement about field functionality during the window |
Contact and Escalation Path | Notice includes a specific support channel, issue tracker link, or contact method for consumers with migration blockers | Generic 'contact support' without a link; no escalation path for consumers who cannot meet the timeline | Validate output contains a URI or email address; assert the contact method is specific to this deprecation |
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Adapt This Prompt
How to adapt
Add a conversational tone directive and a "Why this matters" section. Replace formal migration tables with inline code examples showing before/after snippets. Include a link to the full changelog.
Prompt modification
Add to [CONSTRAINTS]: "Write in a developer blog voice. Start with a one-sentence summary of the change. Include a 'Why this matters' paragraph. Show code snippets for the deprecated field and its replacement side by side. End with a link to [CHANGELOG_URL]."
Watch for
- Overly casual language that buries the timeline
- Missing explicit dates in favor of narrative
- Code snippets that don't match the actual replacement field

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us