Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Freebies — Openapi Swagger Skeleton

    1

    Generate production-grade OpenAPI 3.0/3.1 specifications with typed schemas and security schemes.

    Free

    Security scanned
    Freebies — Openapi Swagger Skeleton

    Freebies — Openapi Swagger Skeleton

    Example session with this skill installed

    Generate an OpenAPI 3.1 YAML spec for a Task Management API with BearerAuth, a GET /tasks endpoint, and a Task schema.

    • Read your context and instructions
    • Compiled the freebies

    I have generated a production-grade OpenAPI 3.1 specification for your Task Management API. It includes a reusable Task schema and Bearer authentication.

    OpenAPI Specification (openapi.yaml)

    openapi: 3.1.0
    info:
      title: Task Management API
      version: 1.0.0
      description: API for managing user tasks and deadlines.
    servers:
      - url: https://api.example.com/v1
        description: Production server
    components:
      securitySchemes:
        BearerAuth:
          type: http
          scheme: bearer
          bearerFormat: JWT
      schemas:
        Task:
          type: object
          required:
            - id
            - title
          properties:
            id:
              type: string
              format: uuid
            title:
              type: string
            completed:
              type: boolean
              default: false
    paths:
      /tasks:
        get:
          summary: List all tasks
          operationId: listTasks
          security:
            - BearerAuth: []
          responses:
            '200':
              description: A list of tasks
              content:
                application/json:
                  schema:
                    type: array
                    items:
                      $ref: '#/components/schemas/Task'
            '401':
              description: Unauthorized
    

    Next steps

    1. Validate this file using the Swagger Editor or spectral lint openapi.yaml.
    2. Reference this file in your README to enable interactive documentation.
    3. Use a generator tool to scaffold your backend controllers from this spec.
    OpenAPI Specification (openapi.yaml

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

    About this skill

    Manually writing OpenAPI specs is tedious and error-prone. This skill automates the creation of production-grade OpenAPI 3.0 and 3.1 specification files, ensuring your API documentation is consistent, valid, and architecturally sound from the start.

    What it does

    • Schema Generation: Generates valid OpenAPI 3.0/3.1 YAML or JSON structures including root info and server definitions.
    • Security Modeling: Defines standard security schemes like BearerAuth and ApiKeyAuth automatically.
    • Path Structuring: Builds explicit operations with summaries, operationIds, and detailed parameters.
    • Component Management: Implements reusable $ref components for shared domain data schemas to reduce duplication.
    • Request/Response Typing: Creates typed request bodies and multi-status response objects for all endpoints.

    How it works

    1. Initialize Root: Define the version, metadata, and environment servers.
    2. Configure Security: Setup authentication protocols and global or local security requirements.
    3. Map Endpoints: Outline paths, methods, and operation metadata.
    4. Link Components: Reference shared schemas for consistent data modeling across the API.

    Frameworks & tools

    OpenAPI 3.0, OpenAPI 3.1, Swagger UI, Redoc, and any backend framework requiring spec-first development or documentation.

    Why this beats prompting it yourself

    Generic prompts often skip critical details like operationId or complex $ref structures, leading to broken documentation or SDK generation errors. This skill follows a deterministic architect workflow to ensure every spec is valid and ready for production tooling.

    Use cases

    • Scaffold a new REST API following a spec-first design approach.
    • Convert raw endpoint descriptions into a formal OpenAPI document.
    • Standardize authentication and error schemas across multiple microservices.

    Known limitations

    Does not perform live API testing or automatic code generation from the resulting spec.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for APIs & Backend.

    Strictly confined to workspace directory. Does not include automatic SDK generation or live endpoint validation.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 3 days ago

    • Free with an Agensi account

    Software
    Zero global installation
    orelevated privileges required.

    File System Read/Write (strictly scoped to current project workspace `./`).

    Permissions

    Read Files

    arget Use Cases: - Generate an OpenAPI 3.0 specification file for my API. - Create a Swagger YAML document for user endpoints. - Write an OpenAPI schema with Bearer authentication.

    Listed3 days ago

    What's inside

    Frequently Asked Questions

    This skill automates the creation of valid OpenAPI 3.0/3.1 YAML or JSON files, ensuring that complex elements like $ref components, security schemes, and operationIds are structured correctly for production use.

    The skill generates standard OpenAPI 3.0 and 3.1 specifications, making it compatible with any tool that supports these formats, including Swagger UI, Redoc, Postman, and various SDK generators.

    No, this skill is strictly for architecting and generating the specification file itself; it does not perform live endpoint testing or write the actual backend controller code.

    You receive the full architectural workflow for generating production-grade specs, including predefined templates for security modeling (like BearerAuth) and reusable component structures.

    Yes, it is ideal for standardization; you can use it to ensure that error schemas, authentication protocols, and metadata are consistent across your entire microservices architecture.

    New in APIs & Backend

    Free