AGENTS Documentation

Official TypeScript developer resources and documentation for dontriskit/AGENTS. Verified technical context for AI.

0 stars TypeScript TypeScript 1 file · ~36,222 tokens
RAW Doc

1. Project Overview & Quickstart (dontriskit/AGENTS)

Technical Documentation: dontriskit/AGENTS

ℹ️ Provenance: Multi-Tier Ingestion · CodeWiki Reference

AGENTS

Agent Skills & Rules

  • Discovered 21 agent rule(s) and prompt configurations.

--- METRICS ---

2. Official Technical Reference & Guides (dontriskit/docs)

File: README.md

Mintlify Starter Kit

Click on Use this template to copy the Mintlify starter kit. The starter kit contains examples including

  • Guide pages
  • Navigation
  • Customizations
  • API Reference pages
  • Use of popular components

Development

Install the Mintlify CLI to preview the documentation changes locally. To install, use the following command

text
npm i -g mintlify

Run the following command at the root of your documentation (where docs.json is)

text
mintlify dev

Publishing Changes

Install our Github App to auto propagate changes from your repo to your deployment. Changes will be deployed to production automatically after pushing to the default branch. Find the link to install on your dashboard.

Troubleshooting

  • Mintlify dev isn't running - Run mintlify install it'll re-install dependencies.
  • Page loads as a 404 - Make sure you are running in a folder with docs.json

File: development.mdx

title: 'Development'

Prerequisite: Please install Node.js (version 19 or higher) before proceeding.
Please upgrade to docs.json before proceeding and delete the legacy mint.json file.

Follow these steps to install and run Mintlify on your operating system:

Step 1: Install Mintlify:

bash npm
npm i -g mintlify
bash yarn
yarn global add mintlify

Step 2: Navigate to the docs directory (where the docs.json file is located) and execute the following command:

bash
mintlify dev

A local preview of your documentation will be available at http://localhost:3000.

Custom Ports

By default, Mintlify uses port 3000. You can customize the port Mintlify runs on by using the --port flag. To run Mintlify on port 3333, for instance, use this command:

bash
mintlify dev --port 3333

If you attempt to run Mintlify on a port that's already in use, it will use the next available port:

md
Port 3000 is already in use. Trying 3001 instead.

Mintlify Versions

Please note that each CLI release is associated with a specific version of Mintlify. If your local website doesn't align with the production version, please update the CLI:

bash npm
npm i -g mintlify@latest
bash yarn
yarn global upgrade mintlify

The CLI can assist with validating reference links made in your documentation. To identify any broken links, use the following command:

bash
mintlify broken-links

Deployment

Unlimited editors available under the [Pro Plan](https://mintlify.com/pricing) and above.

If the deployment is successful, you should see the following:

Code Formatting

We suggest using extensions on your IDE to recognize and format MDX. If you're a VSCode user, consider the MDX VSCode extension for syntax highlighting, and Prettier for code formatting.

Troubleshooting

text
This may be due to an outdated version of node. Try the following:
1. Remove the currently-installed version of mintlify: `npm remove -g mintlify`
2. Upgrade to Node v19 or higher.
3. Reinstall mintlify: `npm install mintlify`
text
Solution: Go to the root of your device and delete the \~/.mintlify folder. Afterwards, run `mintlify dev` again.

Curious about what changed in the CLI version? Check out the CLI changelog.

File: docs.json

{
"$schema": "https://mintlify.com/docs.json",
"theme": "mint",
"name": "Mint Starter Kit",
"colors": {
"primary": "#16A34A",
"light": "#07C983",
"dark": "#15803D"
},
"favicon": "/favicon.svg",
"navigation": {
"tabs": [
{
"tab": "Guides",
"groups": [
{
"group": "Get Started",
"pages": [
"index",
"quickstart",
"development"
]
},
{
"group": "Essentials",
"pages": [
"essentials/markdown",
"essentials/code",
"essentials/images",
"essentials/settings",
"essentials/navigation",
"essentials/reusable-snippets"
]
}
]
},
{
"tab": "API Reference",
"groups": [
{
"group": "API Documentation",
"pages": [
"api-reference/introduction"
]
},
{
"group": "Endpoint Examples",
"pages": [
"api-reference/endpoint/get",
"api-reference/endpoint/create",
"api-reference/endpoint/delete",
"api-reference/endpoint/webhook"
]
}
]
}
],
"global": {
"anchors": [
{
"anchor": "Documentation",
"href": "https://mintlify.com/docs",
"icon": "book-open-cover"
},
{
"anchor": "Community",
"href": "https://mintlify.com/community",
"icon": "slack"
},
{
"anchor": "Blog",
"href": "https://mintlify.com/blog",
"icon": "newspaper"
}
]
}
},
"logo": {
"light": "/logo/light.svg",
"dark": "/logo/dark.svg"
},
"navbar": {
"links": [
{
"label": "Support",
"href": "mailto:[email protected]"
}
],
"primary": {
"type": "button",
"label": "Dashboard",
"href": "https://dashboard.mintlify.com"
}
},
"footer": {
"socials": {
"x": "https://x.com/mintlify",
"github": "https://github.com/mintlify",
"linkedin": "https://linkedin.com/company/mintlify"
}
}
}

File: index.mdx

title: Introduction

Setting up

The first step to world-class documentation is setting up your editing environments.

Get your docs set up locally for easy development Preview your changes before you push to make sure they're perfect

Make it yours

Update your docs to your brand and add valuable content for the best user conversion.

Customize your docs to your company's colors and brands Automatically generate endpoints from an OpenAPI spec Build interactive features and designs to guide your users Check out our showcase of our favorite documentation

File: quickstart.mdx

title: 'Quickstart'

Setup your development

Learn how to update your docs locally and deploy them to the public.

Edit and preview

During the onboarding process, we created a repository on your Github with your docs content. You can find this repository on our [dashboard](https://dashboard.mintlify.com). To clone the repository locally, follow these [instructions](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) in your terminal. Previewing helps you make sure your changes look as intended. We built a command line interface to render these changes locally. 1. Install the [Mintlify CLI](https://www.npmjs.com/package/mintlify) to preview the documentation changes locally with this command: ``` npm i -g mintlify ``` 2. Run the following command at the root of your documentation (where `docs.json` is): ``` mintlify dev ``` If you’re currently using the legacy ```mint.json``` configuration file, please update the Mintlify CLI:
text
```npm i -g mintlify@latest```
  And run the new upgrade command in your docs repository:

  ```mintlify upgrade```
  You should now be using the new ```docs.json``` configuration file. Feel free to delete the ```mint.json``` file from your repository.
</Note>

Deploy your changes

Our Github app automatically deploys your changes to your docs site, so you don't need to manage deployments yourself. You can find the link to install on your [dashboard](https://dashboard.mintlify.com). Once the bot has been successfully installed, there should be a check mark next to the commit hash of the repo. [Commit and push your changes to Git](https://docs.github.com/en/get-started/using-git/pushing-commits-to-a-remote-repository#about-git-push) for your changes to update in your docs site. If you push and don't see that the Github app successfully deployed your changes, you can also manually update your docs through our [dashboard](https://dashboard.mintlify.com).

Update your docs

Add content directly in your files with MDX syntax and React components. You can use any of our components, or even build your own.

Add content to your docs with MDX syntax.

<Card
title="Add Code Blocks"
icon="square-code"
href="/essentials/code"

Add code directly to your docs with syntax highlighting.

<Card
title="Add Images"
icon="image"
href="/essentials/images"

Add images to your docs to make them more engaging.

<Card
title="Add Custom Components"
icon="puzzle-piece"
href="/essentials/reusable-snippets"

Add templates to your docs to make them more reusable.

File: api-reference/introduction.mdx

title: 'Introduction'

If you're not looking to build API reference documentation, you can delete this section by removing the api-reference folder.

Welcome

There are two ways to build API documentation: OpenAPI and MDX components. For the starter kit, we are using the following OpenAPI specification.

<Card
title="Plant Store Endpoints"
icon="leaf"
href="https://github.com/mintlify/starter/blob/main/api-reference/openapi.json"

View the OpenAPI specification file

Authentication

All API endpoints are authenticated using Bearer tokens and picked up from the specification file.

json
"security": [
  {
    "bearerAuth": []
  }
]

File: api-reference/openapi.json

{
"openapi": "3.1.0",
"info": {
"title": "OpenAPI Plant Store",
"description": "A sample API that uses a plant store as an example to demonstrate features in the OpenAPI specification",
"license": {
"name": "MIT"
},
"version": "1.0.0"
},
"servers": [
{
"url": "http://sandbox.mintlify.com"
}
],
"security": [
{
"bearerAuth": []
}
],
"paths": {
"/plants": {
"get": {
"description": "Returns all plants from the system that the user has access to",
"parameters": [
{
"name": "limit",
"in": "query",
"description": "The maximum number of results to return",
"schema": {
"type": "integer",
"format": "int32"
}
}
],
"responses": {
"200": {
"description": "Plant response",
"content": {
"application/json": {
"schema": {
"type": "array",
"items": {
"$ref": "#/components/schemas/Plant"
}
}
}
}
},
"400": {
"description": "Unexpected error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Error"
}
}
}
}
}
},
"post": {
"description": "Creates a new plant in the store",
"requestBody": {
"description": "Plant to add to the store",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/NewPlant"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "plant response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Plant"
}
}
}
},
"400": {
"description": "unexpected error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Error"
}
}
}
}
}
}
},
"/plants/{id}": {
"delete": {
"description": "Deletes a single plant based on the ID supplied",
"parameters": [
{
"name": "id",
"in": "path",
"description": "ID of plant to delete",
"required": true,
"schema": {
"type": "integer",
"format": "int64"
}
}
],
"responses": {
"204": {
"description": "Plant deleted",
"content": {}
},
"400": {
"description": "unexpected error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Error"
}
}
}
}
}
}
}
},
"webhooks": {
"/plant/webhook": {
"post": {
"description": "Information about a new plant added to the store",
"requestBody": {
"description": "Plant added to the store",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/NewPlant"
}
}
}
},
"responses": {
"200": {
"description": "Return a 200 status to indicate that the data was received successfully"
}
}
}
}
},
"components": {
"schemas": {
"Plant": {
"required": [
"name"
],
"type": "object",
"properties": {
"name": {
"description": "The name of the plant",
"type": "string"
},
"tag": {
"description": "Tag to specify the type",
"type": "string"
}
}
},
"NewPlant": {
"allOf": [
{
"$ref": "#/components/schemas/Plant"
},
{
"required": [
"id"
],
"type": "object",
"properties": {
"id": {
"description": "Identification number of the plant",
"type": "integer",
"format": "int64"
}
}
}
]
},
"Error": {
"required": [
"error",
"message"
],
"type": "object",
"properties": {
"error": {
"type": "integer",
"format": "int32"
},
"message": {
"type": "string"
}
}
}
},
"securitySchemes": {
"bearerAuth": {
"type": "http",
"scheme": "bearer"
}
}
}
}

File: api-reference/endpoint/create.mdx

title: 'Create Plant' openapi: 'POST /plants'

File: api-reference/endpoint/delete.mdx

title: 'Delete Plant' openapi: 'DELETE /plants/{id}'

File: api-reference/endpoint/get.mdx

title: 'Get Plants' openapi: 'GET /plants'

File: api-reference/endpoint/webhook.mdx

title: 'New Plant' openapi: 'WEBHOOK /plant/webhook'

File: essentials/code.mdx

title: 'Code Blocks' icon: 'code'

Basic

Inline Code

To denote a word or phrase as code, enclose it in backticks (`).

text
To denote a `word` or `phrase` as code, enclose it in backticks (`).

Code Block

Use fenced code blocks by enclosing code in three backticks and follow the leading ticks with the programming language of your snippet to get syntax highlighting. Optionally, you can also write the name of your code after the programming language.

java helloworld.java
class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
md
```java HelloWorld.java
class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
```

File: essentials/images.mdx

title: 'Images and Embeds' icon: 'image'

Image

Using Markdown

The markdown syntax lets you add images using the following code

md
![title](/path/image.jpg)

Note that the image file size must be less than 5MB. Otherwise, we recommend hosting on a service like Cloudinary or S3. You can then use that URL and embed.

Using Embeds

To get more customizability with images, you can also use embeds to add images

html
<img height="200" src="/path/image.jpg" />

Embeds and HTML elements

Mintlify supports HTML tags in Markdown. This is helpful if you prefer HTML tags to Markdown syntax, and lets you create documentation with infinite flexibility.

iFrames

Loads another HTML page within the document. Most commonly used for embedding videos.

html
<iframe src="https://www.youtube.com/embed/4KzFe50RQkQ"> </iframe>

File: essentials/markdown.mdx

title: 'Markdown Syntax' icon: 'text-size'

Titles

Best used for section headers.

md
## Titles

Subtitles

Best use to subsection headers.

md
### Subtitles

Each title and subtitle creates an anchor and also shows up on the table of contents on the right.

Text Formatting

We support most markdown formatting. Simply add **, _, or ~ around text to format it.

Style How to write it Result
Bold **bold** bold
Italic _italic_ italic
Strikethrough ~strikethrough~ strikethrough

You can combine these. For example, write **_bold and italic_** to get bold and italic text.

You need to use HTML to write superscript and subscript text. That is, add <sup> or <sub> around your text.

Text Size How to write it Result
Superscript <sup>superscript</sup> superscript
Subscript <sub>subscript</sub> subscript

Linking to Pages

You can add a link by wrapping text in [](). You would write [link to google](https://google.com) to link to google.

Links to pages in your docs need to be root-relative. Basically, you should include the entire folder path. For example, [link to text](/writing-content/text) links to the page "Text" in our components section.

Relative links like [link to text](../text) will open slower because we cannot optimize them as easily.

Blockquotes

Singleline

To create a blockquote, add a > in front of a paragraph.

Dorothy followed her through many of the beautiful rooms in her castle.

md
> Dorothy followed her through many of the beautiful rooms in her castle.

Multiline

Dorothy followed her through many of the beautiful rooms in her castle.

The Witch bade her clean the pots and kettles and sweep the floor and keep the fire fed with wood.

md
> Dorothy followed her through many of the beautiful rooms in her castle.
>
> The Witch bade her clean the pots and kettles and sweep the floor and keep the fire fed with wood.

LaTeX

Mintlify supports LaTeX through the Latex component.

8 x (vk x H1 - H2) = (0,1)

md
<Latex>8 x (vk x H1 - H2) = (0,1)</Latex>

File: essentials/navigation.mdx

title: 'Navigation' icon: 'map'

The navigation menu is the list of links on every website.

You will likely update docs.json every time you add a new page. Pages do not show up automatically.

Our navigation syntax is recursive which means you can make nested navigation groups. You don't need to include .mdx in page names.

json regular navigation
"navigation": {
  "tabs": [
    {
      "tab": "Docs",
      "groups": [
        {
          "group": "Getting Started",
          "pages": ["quickstart"]
        }
      ]
    }
  ]
}
json nested navigation
"navigation": {
  "tabs": [
    {
      "tab": "Docs",
      "groups": [
        {
          "group": "Getting Started",
          "pages": [
            "quickstart",
            {
              "group": "Nested Reference Pages",
              "pages": ["nested-reference-page"]
            }
          ]
        }
      ]
    }
  ]
}

Folders

Simply put your MDX files in folders and update the paths in docs.json.

For example, to have a page at https://yoursite.com/your-folder/your-page you would make a folder called your-folder containing an MDX file called your-page.mdx.

You cannot use api for the name of a folder unless you nest it inside another folder. Mintlify uses Next.js which reserves the top-level api folder for internal server calls. A folder name such as api-reference would be accepted.

json navigation with folder
"navigation": {
  "tabs": [
    {
      "tab": "Docs",
      "groups": [
        {
          "group": "Group Name",
          "pages": ["your-folder/your-page"]
        }
      ]
    }
  ]
}

Hidden Pages

MDX files not included in docs.json will not show up in the sidebar but are accessible through the search bar and by linking directly to them.

File: essentials/reusable-snippets.mdx

title: Reusable Snippets icon: 'recycle'

import SnippetIntro from '/snippets/snippet-intro.mdx';

Creating a custom snippet

Pre-condition: You must create your snippet file in the snippets directory.

Any page in the `snippets` directory will be treated as a snippet and will not be rendered into a standalone page. If you want to create a standalone page from the snippet, import the snippet into another file and call it as a component.

Default export

  1. Add content to your snippet file that you want to re-use across multiple
    locations. Optionally, you can add variables that can be filled in via props
    when you import the snippet.
mdx snippets/my-snippet.mdx
Hello world! This is my content I want to reuse across pages. My keyword of the
day is {word}.
The content that you want to reuse must be inside the `snippets` directory in order for the import to work.
  1. Import the snippet into your destination file.
mdx destination-file.mdx
---
title: My title
description: My Description
---

import MySnippet from '/snippets/path/to/my-snippet.mdx';

## Header

Lorem impsum dolor sit amet.

<MySnippet word="bananas" />

Reusable variables

  1. Export a variable from your snippet file:
mdx snippets/path/to/custom-variables.mdx
export const myName = 'my name';

export const myObject = { fruit: 'strawberries' };
  1. Import the snippet from your destination file and use the variable:
mdx destination-file.mdx
---
title: My title
description: My Description
---

import { myName, myObject } from '/snippets/path/to/custom-variables.mdx';

Hello, my name is {myName} and I like {myObject.fruit}.

Reusable components

  1. Inside your snippet file, create a component that takes in props by exporting
    your component in the form of an arrow function.
mdx snippets/custom-component.mdx
export const MyComponent = ({ title }) => (
  <div>
    <h1>{title}</h1>
    <p>... snippet content ...</p>
  </div>
);
MDX does not compile inside the body of an arrow function. Stick to HTML syntax when you can or use a default export if you need to use MDX.
  1. Import the snippet into your destination file and pass in the props
mdx destination-file.mdx
---
title: My title
description: My Description
---

import { MyComponent } from '/snippets/custom-component.mdx';

Lorem ipsum dolor sit amet.

<MyComponent title={'Custom title'} />

File: essentials/settings.mdx

title: 'Global Settings' icon: 'gear'

Every Mintlify site needs a docs.json file with the core configuration settings. Learn more about the properties below.

Properties

Name of your project. Used for the global title.

Example: mintlify

 An array of groups with all the pages within that group The name of the group.
text
Example: `Settings`

</ResponseField>
<ResponseField name="pages" type="string[]">
The relative paths to the markdown files that will serve as pages.

Example: `["customization", "page"]`

</ResponseField>
 Path to logo image or object with path to "light" and "dark" mode logo images Path to the logo in light mode Path to the logo in dark mode Where clicking on the logo links you to Path to the favicon image Hex color codes for your global theme The primary color. Used for most often for highlighted content, section headers, accents, in light mode The primary color for dark mode. Used for most often for highlighted content, section headers, accents, in dark mode The primary color for important buttons The color of the background in both light and dark mode The hex color code of the background in light mode The hex color code of the background in dark mode Array of `name`s and `url`s of links you want to include in the topbar The name of the button.
text
Example: `Contact us`
</ResponseField>
<ResponseField name="url" type="string">
The url once you click on the button. Example: `https://mintlify.com/docs`
</ResponseField>
 Link shows a button. GitHub shows the repo information at the url provided including the number of GitHub stars. If `link`: What the button links to.
text
If `github`: Link to the repository to load GitHub information from.
</ResponseField>
<ResponseField name="name" type="string">
Text inside the button. Only required if `type` is a `link`.
</ResponseField>
 Array of version names. Only use this if you want to show different versions of docs with a dropdown in the navigation bar. An array of the anchors, includes the `icon`, `color`, and `url`. The [Font Awesome](https://fontawesome.com/search?q=heart) icon used to feature the anchor.
text
Example: `comments`
</ResponseField>
<ResponseField name="name" type="string">
The name of the anchor label.

Example: `Community`
</ResponseField>
<ResponseField name="url" type="string">
  The start of the URL that marks what pages go in the anchor. Generally, this is the name of the folder you put your pages in.
</ResponseField>
<ResponseField name="color" type="string">
  The hex color of the anchor icon background. Can also be a gradient if you pass an object with the properties `from` and `to` that are each a hex color.
</ResponseField>
<ResponseField name="version" type="string">
  Used if you want to hide an anchor until the correct docs version is selected.
</ResponseField>
<ResponseField name="isDefaultHidden" type="boolean" default="false">
  Pass `true` if you want to hide the anchor until you directly link someone to docs inside it.
</ResponseField>
<ResponseField name="iconType" default="duotone" type="string">
  One of: "brands", "duotone", "light", "sharp-solid", "solid", or "thin"
</ResponseField>
 Override the default configurations for the top-most anchor. The name of the top-most anchor Font Awesome icon. One of: "brands", "duotone", "light", "sharp-solid", "solid", or "thin" An array of navigational tabs. The name of the tab label. The start of the URL that marks what pages go in the tab. Generally, this is the name of the folder you put your pages in. Configuration for API settings. Learn more about API pages at [API Components](/api-playground/demo). The base url for all API endpoints. If `baseUrl` is an array, it will enable for multiple base url options that the user can toggle.
text
<ResponseField name="auth" type="Auth">
  <Expandable title="Auth">
    <ResponseField name="method" type='"bearer" | "basic" | "key"'>
      The authentication strategy used for all API endpoints.
    </ResponseField>
    <ResponseField name="name" type="string">
    The name of the authentication parameter used in the API playground.

    If method is `basic`, the format should be `[usernameName]:[passwordName]`
    </ResponseField>
    <ResponseField name="inputPrefix" type="string">
    The default value that's designed to be a prefix for the authentication input field.

    E.g. If an `inputPrefix` of `AuthKey` would inherit the default input result of the authentication field as `AuthKey`.
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="playground" type="Playground">
  Configurations for the API playground

  <Expandable title="Playground">
    <ResponseField name="mode" default="show" type='"show" | "simple" | "hide"'>
      Whether the playground is showing, hidden, or only displaying the endpoint with no added user interactivity `simple`

      Learn more at the [playground guides](/api-playground/demo)
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="maintainOrder" type="boolean">
  Enabling this flag ensures that key ordering in OpenAPI pages matches the key ordering defined in the OpenAPI file.

  <Warning>This behavior will soon be enabled by default, at which point this field will be deprecated.</Warning>
</ResponseField>
 A string or an array of strings of URL(s) or relative path(s) pointing to your OpenAPI file.

Examples:

json Absolute "openapi": "https://example.com/openapi.json"
json Relative "openapi": "/openapi.json"
json Multiple "openapi": ["https://example.com/openapi1.json", "/openapi2.json", "/openapi3.json"]

An object of social media accounts where the key:property pair represents the social media platform and the account url.

Example:

json
{
  "x": "https://x.com/mintlify",
  "website": "https://mintlify.com"
}
One of the following values `website`, `facebook`, `x`, `discord`, `slack`, `github`, `linkedin`, `instagram`, `hacker-news`
text
Example: `x`
</ResponseField>
<ResponseField name="property" type="string">
The URL to the social platform.

Example: `https://x.com/mintlify`
</ResponseField>
 Configurations to enable feedback buttons Enables a button to allow users to suggest edits via pull requests Enables a button to allow users to raise an issue about the documentation Customize the dark mode toggle. Set if you always want to show light or dark mode for new users. When not set, we default to the same mode as the user's operating system. Set to true to hide the dark/light mode toggle. You can combine `isHidden` with `default` to force your docs to only use light or dark mode. For example:
text
<CodeGroup>
  ```json Only Dark Mode
  "modeToggle": {
    "default": "dark",
    "isHidden": true
  }
  ```

  ```json Only Light Mode
  "modeToggle": {
    "default": "light",
    "isHidden": true
  }
  ```
  </CodeGroup>

</ResponseField>
 A background image to be displayed behind every page. See example with [Infisical](https://infisical.com/docs) and [FRPC](https://frpc.io).

File: snippets/snippet-intro.mdx

One of the core principles of software development is DRY (Don't Repeat
Yourself). This is a principle that apply to documentation as
well. If you find yourself repeating the same content in multiple places, you
should consider creating a custom snippet to keep your content in sync.

Explore Related Technologies & Topics

View All 9,111+ Repositories →

Discover similar high-velocity repositories, agent skills, and OpenAPI specifications across the ecosystem.

⚡ MCP Servers Model Context Protocol → 🧠 Agent Skills Prompt & rule files → 🔌 OpenAPI Specs REST & Swagger schemas →