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…
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.
$ npx skills add JetBrains/kotlin-web-site --skill add-api-reference -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install JetBrains/kotlin-web-site add-api-reference --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ 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-srcUse ~/.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/
Install the "add-api-reference" agent skill from https://github.com/JetBrains/kotlin-web-site/tree/master/.claude/skills/add-api-reference into .claude/skills/add-api-reference/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "add-api-reference", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/JetBrains/kotlin-web-site/tree/master/.claude/skills/add-api-referenceType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add JetBrains/kotlin-web-site --skill add-api-reference -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install JetBrains/kotlin-web-site add-api-reference --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/JetBrains/kotlin-web-site.git skills-src && mkdir -p .agents/skills && cp -r skills-src/.claude/skills/add-api-reference .agents/skills/add-api-reference && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "add-api-reference" agent skill from https://github.com/JetBrains/kotlin-web-site/tree/master/.claude/skills/add-api-reference into .agents/skills/add-api-reference/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "add-api-reference", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add JetBrains/kotlin-web-site --skill add-api-reference -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install JetBrains/kotlin-web-site add-api-reference --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/JetBrains/kotlin-web-site.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/.claude/skills/add-api-reference .cursor/skills/add-api-reference && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "add-api-reference" agent skill from https://github.com/JetBrains/kotlin-web-site/tree/master/.claude/skills/add-api-reference into .cursor/skills/add-api-reference/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "add-api-reference", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/JetBrains/kotlin-web-site.git --path .claude/skills/add-api-reference--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add JetBrains/kotlin-web-site --skill add-api-reference -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install JetBrains/kotlin-web-site add-api-reference --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/JetBrains/kotlin-web-site.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/.claude/skills/add-api-reference .gemini/skills/add-api-reference && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "add-api-reference" agent skill from https://github.com/JetBrains/kotlin-web-site/tree/master/.claude/skills/add-api-reference into .gemini/skills/add-api-reference/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "add-api-reference", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install JetBrains/kotlin-web-site add-api-referenceInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add JetBrains/kotlin-web-site --skill add-api-reference -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/JetBrains/kotlin-web-site.git skills-src && mkdir -p .github/skills && cp -r skills-src/.claude/skills/add-api-reference .github/skills/add-api-reference && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "add-api-reference" agent skill from https://github.com/JetBrains/kotlin-web-site/tree/master/.claude/skills/add-api-reference into .github/skills/add-api-reference/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "add-api-reference", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add JetBrains/kotlin-web-site --skill add-api-reference -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install JetBrains/kotlin-web-site add-api-reference --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/JetBrains/kotlin-web-site.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/.claude/skills/add-api-reference .opencode/skills/add-api-reference && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "add-api-reference" agent skill from https://github.com/JetBrains/kotlin-web-site/tree/master/.claude/skills/add-api-reference into .opencode/skills/add-api-reference/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "add-api-reference", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
add-api-referencePublish 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. 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.
7 steps, taken from the step headings in SKILL.md.
Read from SKILL.md and the folder at commit 9dbd393. It shows what the files ask for, not the result of running them.
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.
Shell commands in SKILL.md call:
mvnFrom the folder's file list and the shell code blocks in SKILL.md.
Hosts in commands or code, which the agent is likely to contact:
kotlinlang.orggithub.comFrom URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
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.
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.
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.
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.
.claude/skills/add-api-reference/SKILL.md (or your agent's skills folder).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.mdat all times (required byCLAUDE.md).
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.
Ask the user for these (defaults shown are the kotlinx.collections.immutable worked example). Derive the casing variants from the base name.
| Input | Example (immutable) | Notes |
|---|---|---|
| Object / base name | KotlinxCollectionsImmutable | PascalCase. Names the VCS root + build objects. |
| Package segment | collectionsImmutable | camelCase. The references.builds.kotlinx.<seg> package + dir. |
| Const prefix | KOTLINX_COLLECTIONS_IMMUTABLE | SCREAMING_SNAKE_CASE for the BuildParams consts. |
| API id (slug + title) | kotlinx.collections.immutable | The /api/<id>/ slug, the Algolia index name, and the title. Match the repo's dotted/dashed name and desired URL. |
| Git SSH URL | git@github.com:Kotlin/kotlinx.collections.immutable.git | Must be SSH (git@github.com:...). |
| Release tag | v0.5.0 | The 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 label | 0.5.0 | The displayed version. The drop-snapshot step strips a leading v. |
| Dokka HTML output | core/build/dokka/html | datetime-style (core/ module). Root-module libs use build/dokka/html. |
| Dokka templates dir | core/dokka-templates | Where dependsOnDokkaTemplate drops the site templates. Root-module libs use dokka-templates (the helper default). |
| Dokka Gradle task | :kotlinx-collections-immutable:dokkaGenerate | The task stepBuildHtml runs. Confirm against the repo (see Pre-conditions). |
| TOC title | Immutable collections (kotlinx.collections.immutable) | Sidebar label, overview-page card title, and the production-test button text. |
| Library description | A multiplatform library providing immutable and persistent collection interfaces… | One or two sentences for the overview-page card. |
| GitHub repo URL | https://github.com/Kotlin/kotlinx.collections.immutable | HTTPS form of the Git SSH URL; the card's "View on GitHub" link target. |
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.
File: .teamcity/BuildParams.kt
Add four consts inside object BuildParams, after the last library block (currently
KOTLINX_IO_*):
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>_IDThen add one line to the API_URLS list (drives the sitemap index), next to the other
api/... entries:
"api/$<PREFIX>_ID",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".
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:
branch = <PREFIX>_RELEASE_TAG // e.g. "master" or "latest-release"
branchSpec = """
+:refs/heads/(*)
+:refs/tags/(*)
""".trimIndent()
useTagsAsBranches = trueNew directory: .teamcity/references/builds/kotlinx/<segment>/ with three files.
<Base>PrepareDokkaTemplates.kt — verbatim from datetime with new ids:
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:
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.propertiesuses a non-standard version key (datetime overridesstepDropSnapshotto stripversionSuffix=SNAPSHOT), add a matchingstepDropSnapshot = { … }override — see datetime. The default handles a plainversion=…property.
<Base>BuildSearchIndex.kt — verbatim from datetime with new ids:
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
}
}
}
})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):
import references.builds.kotlinx.<segment>.<Base>BuildApiReference
import references.builds.kotlinx.<segment>.<Base>BuildSearchIndex
import references.builds.kotlinx.<segment>.<Base>PrepareDokkaTemplatesInside the Project({ … }) body, add the three build types next to the others:
buildType(<Base>BuildApiReference)
buildType(<Base>BuildSearchIndex)
buildType(<Base>PrepareDokkaTemplates)…and register the VCS root next to the other vcsRoot(...) calls:
vcsRoot(<Base>)File: docs/kr.tree
Inside the <toc-element toc-title="API reference"> block, add a link next to the other
library entries:
<toc-element toc-title="<TOC title>" href="https://kotlinlang.org/api/<api id>/"/>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):
<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.
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.
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.
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.
# .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}",// .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"
}
})// .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)
}
})// .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")
}
})// .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
}
}
}
})# .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)# 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/"/># 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>// 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/');
});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):
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.:kotlinx-collections-immutable:dokkaGenerate vs
:core:dokkaGenerate vs a root :dokkaGenerate. Verify in the repo's settings.gradle.kts
/ core/build.gradle.kts.core/build/dokka/html) and the templates dir
(core/dokka-templates) match where core/build.gradle.kts writes/expects them.gradle.properties — if it's not a plain version=…, add a
stepDropSnapshot override (see datetime's versionSuffix=SNAPSHOT).kotlinx.collections.immutable, like coroutines/serialization).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.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..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.<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
Just SKILL.md in .claude/skills/add-api-reference of JetBrains/kotlin-web-site.
Open the folder on GitHubat commit 9dbd393
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.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Add API Reference this skillJetBrains/kotlin-web-site | 1.6k | — | ~5.3k | Automated safety check: Pass | Apache-2.0 | |
| Kt Search Releasejillesvangurp/kt-search | 155 | — | ~1.2k | Automated safety check: Pass | MIT | |
| Plan ReviewKenjiOhtsuka/harmonica | 131 | — | ~1k | Automated safety check: Pass | MIT | |
| Git GitHub Opsc5inco/compose-pokedexer | 143 | — | ~1.3k | Automated safety check: Pass | MIT | |
| Publish ReleaseAyuilos/Miffan | 182 | — | ~635 | Automated safety check: Pass | AGPL-3.0 | |
| Guided PR Fixupalexvanyo/composelife | 267 | — | ~1k | Automated safety check: Pass | Apache-2.0 |
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…
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" /…
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.
Ayuilos/Miffan
Publish a GitHub release for this fork, with a bilingual changelog that separates fork-owned changes from changes introduced by upstream merges.
alexvanyo/composelife
Performs a guided fixup of a given GitHub PR. An agent skill from alexvanyo/composelife.
alexvanyo/composelife
Helps increment code coverage in this Kotlin Multiplatform project.
JetBrains/kotlin-web-site
Add a new external Writerside documentation source to kotlin-web-site via the TeamCity Kotlin DSL (as a sub-documentation source under KotlinWithCoroutines).
JetBrains/kotlin-web-site
Apply pull-request review comments to the frontend of kotlinlang.org (Next.js, React, TypeScript, CSS Modules under blocks/, components/, pages/, hooks/, utils/, test/).
Categories
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.
Add API Reference fits situations like: wiring a Dokka-generated API reference for a Kotlin/ repo into the site; tasks that involve Android development.
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.
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.
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.
Going by SKILL.md and its folder, Add API Reference needs the command-line tools its instructions call (mvn).
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.
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.
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.
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.
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.
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.