Official agent skill

Add API Reference

by JetBrains in JetBrains/kotlin-web-site

Publish a new kotlinx library API reference on kotlinlang.org/api via the TeamCity Kotlin DSL, the way kotlinx.coroutines, kotlinx.serialization, kotlinx-datetime and kotlinx-io are published.

OfficialApache-2.0Auto-check passedMobile

Install Add API Reference

skills CLI
$ npx skills add JetBrains/kotlin-web-site --skill add-api-reference -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install JetBrains/kotlin-web-site add-api-reference --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/JetBrains/kotlin-web-site.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/add-api-reference .claude/skills/add-api-reference && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
add-api-reference
GitHub stars
1.6k
Token cost
~5.3k tokens
SKILL.md length
1,187 words
Files
1
Skills in repo
3
Repo updated
First seen
Licence
Apache-2.0

At a glance

Publish a new kotlinx library API reference on kotlinlang.org/api via the TeamCity Kotlin DSL, the way kotlinx.coroutines, kotlinx.serialization, kotlinx-datetime and kotlinx-io are published.

  • Works in 7 steps: Add the BuildParams consts + sitemap entry → Add the VCS root → Add the three build objects → …
  • Wiring a Dokka-generated API reference for a Kotlin/ repo into the site
  • SKILL.md covers When to use, Inputs to gather first, Steps — apply these edits and Worked example —…, plus 2 more sections
  • Calls mvn; reaches kotlinlang.org and github.com

What it does

Add API Reference is an agent skill from JetBrains/kotlin-web-site, published by the product's own GitHub organization. Publish a new kotlinx library API reference on kotlinlang.org/api via the TeamCity Kotlin DSL, the way kotlinx.coroutines, kotlinx.serialization, kotlinx-datetime and kotlinx-io are published. Use when wiring a Dokka-generated API reference for a Kotlin/ repo into the site. Covers the BuildParams consts + APIURLS entry, the VCS root, the three build objects (templates / pages / search index), their project registration, the kr.tree nav link, the card on the API references overview page, and the production…

Its SKILL.md is about 5.3k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Mobile, covering Android development. It works with Kotlin, Git and GitHub. The repository describes itself as: The Kotlin programming language website. The licence is Apache-2.0.

When your agent uses it

  • Wiring a Dokka-generated API reference for a Kotlin/ repo into the site
  • Tasks that involve Android development

Example prompts

  • “/add-api-reference”

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. Add the BuildParams consts + sitemap entry
  2. Add the VCS root
  3. Add the three build objects
  4. Register the builds + VCS root in the project
  5. Add the navigation link
  6. Add the card to the API references overview page
  7. Add the production navigation test

What it can do on your machine

Read from SKILL.md and the folder at commit 9dbd393. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • mvn

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • kotlinlang.org
    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Add API Reference loads about 5.3k tokens when it runs. Until then it costs about 153 tokens; SKILL.md has 1,187 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~153
When it runs · the whole SKILL.md, loaded when a task matches
~5.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from JetBrains/kotlin-web-site at commit 9dbd393, republished under its Apache-2.0 licence (© JetBrains). 1,187 words, ~5,337 tokens.

Download SKILL.mdSave it as .claude/skills/add-api-reference/SKILL.md (or your agent's skills folder).
name
add-api-reference
description
Publish a new kotlinx library API reference on kotlinlang.org/api via the TeamCity Kotlin DSL, the way kotlinx.coroutines, kotlinx.serialization, kotlinx-datetime and kotlinx-io are published. Use when wiring a Dokka-generated API reference for a Kotlin/* repo into the site. Covers the BuildParams consts + API_URLS entry, the VCS root, the three build objects (templates / pages / search index), their project registration, the kr.tree nav link, the card on the API references overview page, and the production navigation test. The worked example is kotlinx.collections.immutable (KTL-4524).

Add a new kotlinx API reference

This skill publishes a library's Dokka-generated API reference at https://kotlinlang.org/api/<id>/, built and indexed by the same TeamCity pipeline that produces the coroutines, serialization, datetime and io references.

Everything is wired through the TeamCity Kotlin DSL under .teamcity/. A reference is a fixed set of pieces, all mirroring an existing library — there is no new infrastructure to write, only new config objects plus a couple of site-side links.

The reference implementation is kotlinx-datetime; mirror it. Datetime is the right model for any library whose Dokka output lives under a core/ module (core/build/dokka/html, core/dokka-templates). For a single-module library whose Dokka output is at the repo root, mirror kotlinx-io instead (build/dokka/html, root dokka-templates).

Follow .ai/guidelines.md at all times (required by CLAUDE.md).

When to use

The user wants a Kotlin/* library's API reference served on kotlinlang.org/api alongside the other kotlinx libraries — for example, migrating it off a temporary GitHub Pages site.

Inputs to gather first

Ask the user for these (defaults shown are the kotlinx.collections.immutable worked example). Derive the casing variants from the base name.

InputExample (immutable)Notes
Object / base nameKotlinxCollectionsImmutablePascalCase. Names the VCS root + build objects.
Package segmentcollectionsImmutablecamelCase. The references.builds.kotlinx.<seg> package + dir.
Const prefixKOTLINX_COLLECTIONS_IMMUTABLESCREAMING_SNAKE_CASE for the BuildParams consts.
API id (slug + title)kotlinx.collections.immutableThe /api/<id>/ slug, the Algolia index name, and the title. Match the repo's dotted/dashed name and desired URL.
Git SSH URLgit@github.com:Kotlin/kotlinx.collections.immutable.gitMust be SSH (git@github.com:...).
Release tagv0.5.0The branch/tag to build from. A tag (e.g. v0.5.0) must be wired with the full ref — see Step 2. A branch (e.g. master, latest-release) is used as-is.
Release label0.5.0The displayed version. The drop-snapshot step strips a leading v.
Dokka HTML outputcore/build/dokka/htmldatetime-style (core/ module). Root-module libs use build/dokka/html.
Dokka templates dircore/dokka-templatesWhere dependsOnDokkaTemplate drops the site templates. Root-module libs use dokka-templates (the helper default).
Dokka Gradle task:kotlinx-collections-immutable:dokkaGenerateThe task stepBuildHtml runs. Confirm against the repo (see Pre-conditions).
TOC titleImmutable collections (kotlinx.collections.immutable)Sidebar label, overview-page card title, and the production-test button text.
Library descriptionA multiplatform library providing immutable and persistent collection interfaces…One or two sentences for the overview-page card.
GitHub repo URLhttps://github.com/Kotlin/kotlinx.collections.immutableHTTPS form of the Git SSH URL; the card's "View on GitHub" link target.

Steps — apply these edits

Make the edits in this order. Each is anchored to an existing pattern; append the new entry alongside the others rather than reformatting the file. Replace the <…> placeholders with the gathered inputs; the worked example below shows every value filled in.

1. Add the BuildParams consts + sitemap entry

File: .teamcity/BuildParams.kt

Add four consts inside object BuildParams, after the last library block (currently KOTLINX_IO_*):

kotlin
const val <PREFIX>_RELEASE_TAG = "<release tag>"
const val <PREFIX>_RELEASE_LABEL = "<release label>"
const val <PREFIX>_ID = "<api id>"
const val <PREFIX>_TITLE = <PREFIX>_ID

Then add one line to the API_URLS list (drives the sitemap index), next to the other api/... entries:

kotlin
"api/$<PREFIX>_ID",
2. Add the VCS root

New file: .teamcity/references/vcsRoots/<Base>.kt.

Building from a tag (e.g. v0.5.0 — the usual case for a stable release). Use the full ref via the VCS.tag(...) helper and a tag-only branchSpec. Do not pass a bare tag name to branch with a +:refs/heads/(*) spec — TeamCity expands the short name to refs/heads/<tag>, which doesn't exist, and fails with "Cannot find revision of the default branch".

kotlin
package references.vcsRoots

import BuildParams.<PREFIX>_RELEASE_TAG
import common.extensions.VCS
import jetbrains.buildServer.configs.kotlin.vcs.GitVcsRoot

object <Base> : GitVcsRoot({
  name = "<api id> vcs root"
  url = "<git SSH URL>"
  branch = VCS.tag(<PREFIX>_RELEASE_TAG)   // refs/tags/<release tag>
  branchSpec = "+:refs/tags/*"
  useTagsAsBranches = true
  authMethod = uploadedKey {
    uploadedKey = "teamcity"
  }
})

Building from a branch (e.g. master, latest-release — the kotlinx-io / datetime style). Use the branch name directly with the heads+tags spec:

kotlin
  branch = <PREFIX>_RELEASE_TAG            // e.g. "master" or "latest-release"
  branchSpec = """
    +:refs/heads/(*)
    +:refs/tags/(*)
  """.trimIndent()
  useTagsAsBranches = true
3. Add the three build objects

New directory: .teamcity/references/builds/kotlinx/<segment>/ with three files.

<Base>PrepareDokkaTemplates.kt — verbatim from datetime with new ids:

kotlin
package references.builds.kotlinx.<segment>

import BuildParams.<PREFIX>_ID
import BuildParams.<PREFIX>_TITLE
import jetbrains.buildServer.configs.kotlin.BuildType
import references.templates.PrepareDokkaTemplate

object <Base>PrepareDokkaTemplates : BuildType({
    name = "$<PREFIX>_ID templates"
    description = "Build dokka templates for <human name>"

    templates(PrepareDokkaTemplate)

    params {
        param("env.ALGOLIA_INDEX_NAME", <PREFIX>_ID)
        param("env.API_REFERENCE_NAME", <PREFIX>_TITLE)
    }
})

<Base>BuildApiReference.kt — core/-module shape (datetime). Drop the pagesRoot private const, the stepBuildHtml task, and the dependsOnDokkaTemplate dir to match a root-module lib (io) if applicable:

kotlin
package references.builds.kotlinx.<segment>

import BuildParams.<PREFIX>_ID
import BuildParams.<PREFIX>_RELEASE_LABEL
import references.BuildApiPages
import references.dependsOnDokkaTemplate
import references.scriptBuildHtml
import references.vcsRoots.<Base>

private const val DOKKA_HTML_RESULT = "<dokka html output>"

object <Base>BuildApiReference : BuildApiPages(
    apiId = <PREFIX>_ID,
    releaseTag = <PREFIX>_RELEASE_LABEL,
    pagesRoot = DOKKA_HTML_RESULT,
    stepBuildHtml = {
        scriptBuildHtml { tasks = "<dokka gradle task>" }
    },
    init = {
        vcs {
            root(<Base>)
        }
        dependencies {
            dependsOnDokkaTemplate(<Base>PrepareDokkaTemplates, "<dokka templates dir>")
        }
    })

If the library's gradle.properties uses a non-standard version key (datetime overrides stepDropSnapshot to strip versionSuffix=SNAPSHOT), add a matching stepDropSnapshot = { … } override — see datetime. The default handles a plain version=… property.

<Base>BuildSearchIndex.kt — verbatim from datetime with new ids:

kotlin
package references.builds.kotlinx.<segment>

import BuildParams.<PREFIX>_ID
import templates.TemplateSearchIndex

object <Base>BuildSearchIndex : TemplateSearchIndex({
    name = "$<PREFIX>_ID search"
    description = "Build search index for <human name>"

    params {
        param("env.ALGOLIA_INDEX_NAME", "$<PREFIX>_ID")
    }

    dependencies {
        dependency(<Base>BuildApiReference) {
            snapshot {}
            artifacts {
                artifactRules = """
                    pages.zip!** => dist/api/$<PREFIX>_ID/
                """.trimIndent()
                cleanDestination = true
            }
        }
    }
})
4. Register the builds + VCS root in the project

File: .teamcity/references/BuildApiReferencesProject.kt

Add the imports (alongside the existing references.builds.kotlinx.* and references.vcsRoots.* imports — the latter is a wildcard, so no vcsRoot import is needed):

kotlin
import references.builds.kotlinx.<segment>.<Base>BuildApiReference
import references.builds.kotlinx.<segment>.<Base>BuildSearchIndex
import references.builds.kotlinx.<segment>.<Base>PrepareDokkaTemplates

Inside the Project({ … }) body, add the three build types next to the others:

kotlin
buildType(<Base>BuildApiReference)
buildType(<Base>BuildSearchIndex)
buildType(<Base>PrepareDokkaTemplates)

…and register the VCS root next to the other vcsRoot(...) calls:

kotlin
vcsRoot(<Base>)

File: docs/kr.tree

Inside the <toc-element toc-title="API reference"> block, add a link next to the other library entries:

xml
<toc-element toc-title="<TOC title>" href="https://kotlinlang.org/api/<api id>/"/>
Show full SKILL.md (483 more words)Show less
6. Add the card to the API references overview page

File: docs/topics/api-references.md

The sidebar link is not enough — the library must also appear on the "API references" overview page. Add a <panel> to the <panels columns="2">, in the position that matches the kr.tree ordering (this page is not alphabetical; place it relative to the same neighbours it has in the TOC):

xml
<panel>
    <title><TOC title></title>
    <p><library description></p>
    <img src="github.svg" width="18" alt="GitHub"/> <a href="<GitHub repo URL>">View on GitHub</a><br/><br/>
    <a href="https://kotlinlang.org/api/<api id>/" as="button" icon="arrow-right" icon-position="right">Browse API</a>
</panel>

Keep the <title> text identical to the kr.tree entry's toc-title and the "Browse API" button URL identical to the kr.tree entry's href from Step 5 so the two stay in sync. Use the literal View on GitHub as the GitHub link text.

7. Add the production navigation test

File: test/production/api-navigation.spec.ts

Add a test mirroring the existing ones, using the TOC title as the button text and the /api/<id>/ slug. The button text must match the kr.tree toc-title from Step 5.

typescript
test.skip('Click on "<TOC title short>" button should open the related page', async ({ page }) => {
    const button = await hoverOverApiElement(page, '<TOC title short>');
    await expect(button).toBeVisible();
    await button.click();
    expect(page.url()).toContain('/api/<api id>/');
});

<TOC title short> is the leading text of the TOC title that hoverOverApiElement matches (e.g. Immutable collections).

Add the test as test.skip(...): the suite runs against the deployed production site, where /api/<id>/ 404s until the new TeamCity build has published the reference. Un-skip it (test.skip → test) once the page is live.

Worked example — kotlinx.collections.immutable

The exact change for KTL-4524. Inputs: base KotlinxCollectionsImmutable, segment collectionsImmutable, prefix KOTLINX_COLLECTIONS_IMMUTABLE, id kotlinx.collections.immutable, repo git@github.com:Kotlin/kotlinx.collections.immutable.git, tag v0.5.0, label 0.5.0, core/ module layout.

diff
# .teamcity/BuildParams.kt  (after the KOTLINX_IO_* block)
+  const val KOTLINX_COLLECTIONS_IMMUTABLE_RELEASE_TAG = "v0.5.0"
+  const val KOTLINX_COLLECTIONS_IMMUTABLE_RELEASE_LABEL = "0.5.0"
+  const val KOTLINX_COLLECTIONS_IMMUTABLE_ID = "kotlinx.collections.immutable"
+  const val KOTLINX_COLLECTIONS_IMMUTABLE_TITLE = KOTLINX_COLLECTIONS_IMMUTABLE_ID

# .teamcity/BuildParams.kt  (in API_URLS)
     "api/$KOTLINX_IO_ID",
     "api/$KOTLINX_METADATA_ID",
+    "api/$KOTLINX_COLLECTIONS_IMMUTABLE_ID",
     "api/${KGP_REFERENCE.urlPart}",
kotlin
// .teamcity/references/vcsRoots/KotlinxCollectionsImmutable.kt  (new)
package references.vcsRoots

import BuildParams.KOTLINX_COLLECTIONS_IMMUTABLE_RELEASE_TAG
import common.extensions.VCS
import jetbrains.buildServer.configs.kotlin.vcs.GitVcsRoot

object KotlinxCollectionsImmutable : GitVcsRoot({
  name = "kotlinx.collections.immutable vcs root"
  url = "git@github.com:Kotlin/kotlinx.collections.immutable.git"
  // Pinned to the stable release tag (full ref so the short name isn't resolved as a head).
  branch = VCS.tag(KOTLINX_COLLECTIONS_IMMUTABLE_RELEASE_TAG)
  branchSpec = "+:refs/tags/*"
  useTagsAsBranches = true
  authMethod = uploadedKey {
    uploadedKey = "teamcity"
  }
})
kotlin
// .teamcity/references/builds/kotlinx/collectionsImmutable/KotlinxCollectionsImmutablePrepareDokkaTemplates.kt  (new)
package references.builds.kotlinx.collectionsImmutable

import BuildParams.KOTLINX_COLLECTIONS_IMMUTABLE_ID
import BuildParams.KOTLINX_COLLECTIONS_IMMUTABLE_TITLE
import jetbrains.buildServer.configs.kotlin.BuildType
import references.templates.PrepareDokkaTemplate

object KotlinxCollectionsImmutablePrepareDokkaTemplates : BuildType({
    name = "$KOTLINX_COLLECTIONS_IMMUTABLE_ID templates"
    description = "Build dokka templates for Kotlinx Collections Immutable"

    templates(PrepareDokkaTemplate)

    params {
        param("env.ALGOLIA_INDEX_NAME", KOTLINX_COLLECTIONS_IMMUTABLE_ID)
        param("env.API_REFERENCE_NAME", KOTLINX_COLLECTIONS_IMMUTABLE_TITLE)
    }
})
kotlin
// .teamcity/references/builds/kotlinx/collectionsImmutable/KotlinxCollectionsImmutableBuildApiReference.kt  (new)
package references.builds.kotlinx.collectionsImmutable

import BuildParams.KOTLINX_COLLECTIONS_IMMUTABLE_ID
import BuildParams.KOTLINX_COLLECTIONS_IMMUTABLE_RELEASE_LABEL
import references.BuildApiPages
import references.dependsOnDokkaTemplate
import references.scriptBuildHtml
import references.scriptDropSnapshot
import references.vcsRoots.KotlinxCollectionsImmutable

private const val DOKKA_HTML_RESULT = "core/build/dokka/html"

object KotlinxCollectionsImmutableBuildApiReference : BuildApiPages(
    apiId = KOTLINX_COLLECTIONS_IMMUTABLE_ID,
    releaseTag = KOTLINX_COLLECTIONS_IMMUTABLE_RELEASE_LABEL,
    pagesRoot = DOKKA_HTML_RESULT,
    // gradle.properties has `version=0.5.0` + a separate `versionSuffix=SNAPSHOT`; strip the
    // suffix (the default drop-snapshot only rewrites `version=`). Same as datetime.
    stepDropSnapshot = {
        scriptDropSnapshot {
            // language=bash
            scriptContent = """
                #!/bin/bash
                sed -i -E "s/versionSuffix=SNAPSHOT//gi" ./gradle.properties
            """.trimIndent()
        }
    },
    stepBuildHtml = {
        scriptBuildHtml { tasks = ":kotlinx-collections-immutable:dokkaGenerate" }
    },
    init = {
        vcs {
            root(KotlinxCollectionsImmutable)
        }
        dependencies {
            dependsOnDokkaTemplate(KotlinxCollectionsImmutablePrepareDokkaTemplates, "core/dokka-templates")
        }
    })
kotlin
// .teamcity/references/builds/kotlinx/collectionsImmutable/KotlinxCollectionsImmutableBuildSearchIndex.kt  (new)
package references.builds.kotlinx.collectionsImmutable

import BuildParams.KOTLINX_COLLECTIONS_IMMUTABLE_ID
import templates.TemplateSearchIndex

object KotlinxCollectionsImmutableBuildSearchIndex : TemplateSearchIndex({
    name = "$KOTLINX_COLLECTIONS_IMMUTABLE_ID search"
    description = "Build search index for Kotlinx Collections Immutable"

    params {
        param("env.ALGOLIA_INDEX_NAME", "$KOTLINX_COLLECTIONS_IMMUTABLE_ID")
    }

    dependencies {
        dependency(KotlinxCollectionsImmutableBuildApiReference) {
            snapshot {}
            artifacts {
                artifactRules = """
                    pages.zip!** => dist/api/$KOTLINX_COLLECTIONS_IMMUTABLE_ID/
                """.trimIndent()
                cleanDestination = true
            }
        }
    }
})
diff
# .teamcity/references/BuildApiReferencesProject.kt  (imports)
+import references.builds.kotlinx.collectionsImmutable.KotlinxCollectionsImmutableBuildApiReference
+import references.builds.kotlinx.collectionsImmutable.KotlinxCollectionsImmutableBuildSearchIndex
+import references.builds.kotlinx.collectionsImmutable.KotlinxCollectionsImmutablePrepareDokkaTemplates

# .teamcity/references/BuildApiReferencesProject.kt  (Project body)
+    buildType(KotlinxCollectionsImmutableBuildApiReference)
+    buildType(KotlinxCollectionsImmutableBuildSearchIndex)
+    buildType(KotlinxCollectionsImmutablePrepareDokkaTemplates)
...
+    vcsRoot(KotlinxCollectionsImmutable)
diff
# docs/kr.tree  (inside <toc-element toc-title="API reference">)
     <toc-element toc-title="Date and time (kotlinx-datetime)" href="https://kotlinlang.org/api/kotlinx-datetime/"/>
+    <toc-element toc-title="Immutable collections (kotlinx.collections.immutable)" href="https://kotlinlang.org/api/kotlinx.collections.immutable/"/>
     <toc-element toc-title="JVM Metadata (kotlinx-metadata-jvm)" href="https://kotlinlang.org/api/kotlinx-metadata-jvm/"/>
diff
# docs/topics/api-references.md  (inside <panels columns="2">, after the datetime panel)
         </panel>
+        <panel>
+            <title>Immutable collections (kotlinx.collections.immutable)</title>
+            <p>A multiplatform library providing immutable and persistent collection interfaces and implementations. It offers efficient copy-on-write operations that share structure between versions, so updating a collection doesn't copy the whole thing.</p>
+            <img src="github.svg" width="18" alt="GitHub"/> <a href="https://github.com/Kotlin/kotlinx.collections.immutable">View on GitHub</a><br/><br/>
+            <a href="https://kotlinlang.org/api/kotlinx.collections.immutable/" as="button" icon="arrow-right" icon-position="right">Browse API</a>
+        </panel>
         <panel>
             <title>Kotlin Gradle plugins (kotlin-gradle-plugin)</title>
typescript
// test/production/api-navigation.spec.ts  (new test next to the others; skipped until the page is live)
test.skip('Click on "Immutable collections" button should open the related page', async ({ page }) => {
    const immutableButton = await hoverOverApiElement(page, 'Immutable collections');
    await expect(immutableButton).toBeVisible();
    await immutableButton.click();
    expect(page.url()).toContain('/api/kotlinx.collections.immutable/');
});

Pre-conditions to confirm against the source repo

Before relying on the datetime defaults, check these against Kotlin/kotlinx.collections.immutable at the chosen tag (the issue reporter offered to share the build details on request):

  • The v0.5.0 tag exists. If the stable release isn't tagged yet, build from latest-release (datetime-style) or master (io-style) and update the label accordingly.
  • The Dokka Gradle task path — :kotlinx-collections-immutable:dokkaGenerate vs :core:dokkaGenerate vs a root :dokkaGenerate. Verify in the repo's settings.gradle.kts / core/build.gradle.kts.
  • The Dokka HTML output path (core/build/dokka/html) and the templates dir (core/dokka-templates) match where core/build.gradle.kts writes/expects them.
  • The version property in gradle.properties — if it's not a plain version=…, add a stepDropSnapshot override (see datetime's versionSuffix=SNAPSHOT).
  • The id/slug matches the desired public URL and the repo naming (immutable uses the dotted kotlinx.collections.immutable, like coroutines/serialization).

Verify

  • Compile/validate the TeamCity DSL so the new objects, imports and registration are valid Kotlin: cd .teamcity && mvn -q teamcity-configs:generate (or the repo's configured DSL check). It should generate without errors and emit configs for the three new build types.
  • Confirm docs/kr.tree is still valid XML and docs/topics/api-references.md still parses (its <panels> markup is well-formed), that the new TOC entry sits under "API reference", and that the new <panel> is inside the <panels columns="2"> with a <title> and "Browse API" URL matching the TOC entry.
  • The change should touch only: .teamcity/BuildParams.kt, .teamcity/references/BuildApiReferencesProject.kt, the new vcsRoots/<Base>.kt, the three new builds/kotlinx/<segment>/*.kt files, docs/kr.tree, docs/topics/api-references.md, and test/production/api-navigation.spec.ts — nothing else.
  • After the build runs on TeamCity, <Base>BuildApiReference → <Base>BuildSearchIndex produce and index /api/<id>/. Until that deploy lands, the new production navigation test stays test.skip (it hits the live site); un-skip it once /api/<id>/ is reachable.

© JetBrains, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/add-api-reference of JetBrains/kotlin-web-site.

Open the folder on GitHubat commit 9dbd393

Compare with similar skills

Add API Reference next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Add API Reference compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Add API Reference this skillJetBrains/kotlin-web-site1.6k—~5.3kAutomated safety check: PassApache-2.0
Kt Search Releasejillesvangurp/kt-search155—~1.2kAutomated safety check: PassMIT
Plan ReviewKenjiOhtsuka/harmonica131—~1kAutomated safety check: PassMIT
Git GitHub Opsc5inco/compose-pokedexer143—~1.3kAutomated safety check: PassMIT
Publish ReleaseAyuilos/Miffan182—~635Automated safety check: PassAGPL-3.0
Guided PR Fixupalexvanyo/composelife267—~1kAutomated safety check: PassApache-2.0

Similar skills

  • Kt Search Release

    jillesvangurp/kt-search

    A skill your agent uses when the user wants to cut, publish, tag, or create a GitHub release for kt-search, especially when the task includes version bumping, validating that commits are pushed…

    155 GitHub stars~1.2k tokensUpdated 3 mo ago
    DevelopmentAuto-check passed
  • Plan Review

    KenjiOhtsuka/harmonica

    A skill your agent uses when reviewing the Harmonica restart plan against reality — after a phase PR or milestone merges, before proposing the next phase, or when asked "are the specs up to date" /…

    131 GitHub stars~1k tokensUpdated 15 days ago
    DatabasesAuto-check passed
  • Git GitHub Ops

    c5inco/compose-pokedexer

    Handles Pokedexer Git and GitHub workflows: inspect changes, prepare commit messages, manage branches and pushes, and create or update issues and pull requests with safe file-based inputs.

    143 GitHub stars~1.3k tokensUpdated 4 days ago
    DevelopmentAuto-check passed
  • Publish Release

    Ayuilos/Miffan

    Publish a GitHub release for this fork, with a bilingual changelog that separates fork-owned changes from changes introduced by upstream merges.

    182 GitHub stars~635 tokensUpdated yesterday
    MobileAuto-check passed
  • Guided PR Fixup

    alexvanyo/composelife

    Performs a guided fixup of a given GitHub PR. An agent skill from alexvanyo/composelife.

    267 GitHub stars~1k tokensUpdated today
    MobileAuto-check passed
  • Improve Code Coverage

    alexvanyo/composelife

    Helps increment code coverage in this Kotlin Multiplatform project.

    267 GitHub stars~1.1k tokensUpdated today
    MobileAuto-check passed

More from JetBrains/kotlin-web-site

  • Add Writerside Doc Module

    JetBrains/kotlin-web-site

    Official

    Add a new external Writerside documentation source to kotlin-web-site via the TeamCity Kotlin DSL (as a sub-documentation source under KotlinWithCoroutines).

    1.6k GitHub stars~1.9k tokensUpdated yesterday
    Auto-check passed
  • Fix Frontend Review Comments

    JetBrains/kotlin-web-site

    Official

    Apply pull-request review comments to the frontend of kotlinlang.org (Next.js, React, TypeScript, CSS Modules under blocks/, components/, pages/, hooks/, utils/, test/).

    1.6k GitHub stars~444 tokensUpdated yesterday
    Auto-check passed

Works with

Categories

Questions about Add API Reference

What does Add API Reference do?

Publish a new kotlinx library API reference on kotlinlang.org/api via the TeamCity Kotlin DSL, the way kotlinx.coroutines, kotlinx.serialization, kotlinx-datetime and kotlinx-io are published. Add API Reference is an agent skill from JetBrains/kotlin-web-site, published by the product's own GitHub organization.serialization, kotlinx-datetime and kotlinx-io are published.

When should I use Add API Reference?

Add API Reference fits situations like: wiring a Dokka-generated API reference for a Kotlin/ repo into the site; tasks that involve Android development.

How do I install Add API Reference in Claude Code?

Run `npx skills add JetBrains/kotlin-web-site --skill add-api-reference -a claude-code`. Or copy the skill folder (.claude/skills/add-api-reference in JetBrains/kotlin-web-site) into .claude/skills/add-api-reference in your project. Claude Code loads it when a task matches its description.

How do I install Add API Reference in Codex?

Run `npx skills add JetBrains/kotlin-web-site --skill add-api-reference -a codex`. Or copy the skill folder (.claude/skills/add-api-reference in JetBrains/kotlin-web-site) into .agents/skills/add-api-reference in your project. Codex loads it when a task matches its description.

Can I use Add API Reference in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add JetBrains/kotlin-web-site --skill add-api-reference -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/add-api-reference, .gemini/skills/add-api-reference, .github/skills/add-api-reference and .opencode/skills/add-api-reference in your project.

What does Add API Reference need to run?

Going by SKILL.md and its folder, Add API Reference needs the command-line tools its instructions call (mvn).

Does Add API Reference access the network?

SKILL.md names 2 domains. In commands or code: kotlinlang.org and github.com; the agent is likely to contact these when it follows the instructions. This is read from the text; nothing was executed.

Is Add API Reference safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Add API Reference use?

Add API Reference is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Add API Reference use?

About 5.3k tokens (SKILL.md is roughly 21k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Add API Reference?

Skills that share tags, products or a category with Add API Reference: Kt Search Release (jillesvangurp/kt-search, 155 stars), Plan Review (KenjiOhtsuka/harmonica, 131 stars), Git GitHub Ops (c5inco/compose-pokedexer, 143 stars) and Publish Release (Ayuilos/Miffan, 182 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Add API Reference?

JetBrains (a GitHub organization, an official publisher) maintains it in JetBrains/kotlin-web-site, which has 1,624 GitHub stars. The repository holds 3 skills in this directory. The repository was last updated on October 6, 2026.

Source: JetBrains/kotlin-web-site on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.