Elva

AI-assisted spec editing

Describe an OpenAPI change in plain language and review the proposed diff before accepting it. The spec editor lets you inspect, apply, or reject the suggestion.

Edit by describing, not hand-typing

The composer uses your instruction and relevant specification content to propose targeted edits. Review the diff for correctness and compatibility before applying it.

Suggestions can add or change fields, descriptions, examples, and operations. Check the whole affected schema and existing consumers, especially when changing required fields or constraints.

From prompt to applied patch

1

Describe the change

Open the composer in the editor and type what you want in plain language, for example "add a cursor pagination parameter to GET /orders". The composer sends your instruction to Elva's model proxy along with the relevant slices of your spec.

2

Preview the diff

Elva returns a patch proposal card summarizing each change (+ add, ~ update, - remove) with a count of changes in your file. Expand any row with View changes to inspect the exact content that will be added, updated, or removed, rendered as a syntax-highlighted diff.

3

Apply or discard

Press Accept all to apply the patch. The editor updates, the card flips to Changes Applied, and Elva jumps you to the first changed line. Press Reject all to discard the proposal with zero side effects.

A returned patch is just a JSON array of operations. Here is the shape the composer works with:

RFC-6902 JSON Patch

   [
    {
      "op": "add",
      "path": "/components/schemas/User/properties/email",
      "value": { "type": "string", "format": "email" }
    },
    {
      "op": "add",
      "path": "/components/schemas/User/required/-",
      "value": "email"
    }
  ]

Notice the second operation appends to the required array with /- instead of overwriting it. That is the additive discipline in action: the new field is added and marked required without disturbing the fields already there.

Live linting with a Fix with AI shortcut

As you type, Elva lints your spec with Spectral against the recommended OpenAPI ruleset and surfaces issues inline in the editor. Each finding carries a severity: error, warning, info, or hint.

Every issue comes with a Fix with AI quick-fix. Trigger it and Elva drafts the composer prompt for you from the marker, seeding the composer with the exact rule, message, and location so you can turn a lint failure into an applied patch in one move.

The editor validates your specification and displays findings near the affected content. Validation may run locally or use the hosted service depending on the document and environment.

Choose your model provider

Choose an available provider in AI Model Settings. Your workspace settings determine whether you can use shared quota or a provider key from your own account.

Route composer requests to OpenAI models through the proxy. Provide your own OpenAI key in AI Model Settings, or leave it blank to use Elva's configured key where available.

Details worth knowing

What exactly does Fix with AI do?

Use the lint finding to ask for a focused edit. Review the proposed diff and decide whether to accept it. Lint suggestions do not silently change your specification.

Which Spectral rules run?

Elva extends the recommended OpenAPI ruleset out of the box. You can tune which rules are active, toggle individual checks, and adjust severities, so the linting matches your team's house style.

Can an AI edit break my spec?

Review the proposed diff before accepting it. Validation catches malformed proposals, but you should still check endpoint behavior, schemas, examples, and required fields before saving.

Are edits precise or sweeping?

Precise. The composer emits granular add, remove, and replace operations scoped to the exact path you want changed. It appends to arrays and inserts single properties rather than replacing entire objects, so surrounding content is preserved.

Stop a request or revise an instruction

Use Stop while generation is in progress to end the current request. Inspect the editor and any completed proposal before trying again. In the spec editor, accept or reject a proposal explicitly; the contract wizard has a separate flow in which completed changes can already be applied.

Sections