agentleFS
KotlinKotlin/kotlinx-rpc/.claude/skills/run-local-verifications/SKILL.md

run-local-verifications

Skill1.1k starsChanged 5 days agoApache-2.0View on GitHub

Determine which LOCAL verification checks to run for kotlinx-rpc changes and execute them on the developer's machine. TeamCity builds and GitHub Actions workflows are out of scope -- this skill covers only what can and should be run locally before pushing. Use this skill whenever changes are made to the codebase and you need to verify correctness before committing or opening a PR. Also use it when the user asks to "run checks", "verify changes", "run verifications", "what checks do I need", "validate my changes", "pre-PR checks", or "local checks". Trigger proactively after completing any code modification task -- even if the user doesn't explicitly ask, suggest which verifications are relevant based on what changed.

We split this skill into the rules it gives an agent

17 rules. About 0 are common, 2 are distinctive, and 15 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈2

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 15

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Use the running_gradle_builds skill for all Gradle build/generation tasks and the running_gradle_tests skill for all Gradle test tasks.

    line 24
  2. Distinctive:

    Before running anything, determine which files were modified.

    line 31
  3. Very specific:

    After running the verification checks above, run tests for the specific modules you changed using the running_gradle_tests skill.

    line 61
  4. Very specific:

    All JVM tests for a module (preferred for commonMain changes): task <module>:jvmTest

    line 71
  5. Very specific:

    Run checkLegacyAbi via running_gradle_builds -- if it fails, run updateLegacyAbi and commit

    line 77
  6. Very specific:

    Run detekt via running_gradle_builds -- check output

    line 78
  7. Very specific:

    Run :jpms-check:compileJava via running_gradle_builds

    line 79
  8. Very specific:

    Use verify-compiler-plugin-compatibility skill for multi-version check

    line 84
  9. Very specific:

    Run dumpPlatformTable --no-configuration-cache via running_gradle_builds then commit if changed

    line 87
  10. Very specific:

    Run ./scripts/validate_published_artifacts.sh --dump -s via shell then commit if changed

    line 88
  11. Very specific:

    Run ./scripts/update_implicit_types.sh via shell then commit if changed (if protoc-gen changed)

    line 97
  12. Very specific:

    Run relevant module jvmTest via running_gradle_tests

    line 99
  13. Very specific:

    Run kotlinUpgradeYarnLock and kotlinWasmUpgradeYarnLock via running_gradle_builds

    line 110
  14. Very specific:

    Run checkLegacyAbi via running_gradle_builds -- API dumps may need updating

    line 111
  15. Distinctive:

    Verify Writerside markup is valid (CI will build it, not runnable locally)

    line 116
  16. Very specific:

    If you changed the changelog: run updateDocsChangelog via running_gradle_builds

    line 117
  17. Very specific:

    Troubleshooting: read references/troubleshooting.md — consult when verifications fail unexpectedly

    line 122

≈ “Common” is an estimate: at least 1 in 5 of the 308,232 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Run Local Verifications

Identify which verification checks are needed based on what changed, then run them locally. This skill covers only checks that can be executed on the developer's machine. TeamCity CI builds and GitHub Actions workflows are out of scope -- they run automatically on push/PR and cannot be triggered from here.

How to Execute

Use the running_gradle_builds skill for all Gradle build/generation tasks and the running_gradle_tests skill for all Gradle test tasks. Do NOT run ./gradlew directly via shell. The only exception is ./scripts/update_implicit_types.sh and ./scripts/validate_published_artifacts.sh which are standalone shell scripts.

Quick Start: Identify What Changed

Before running anything, determine which files were modified. Use git diff or git status to see the changed files, then match them against the decision table below.

Decision Table

Match changed paths to required verifications. Multiple rows can match -- run all that apply. The "Gradle task" column shows the task name to pass to the appropriate Gradle skill.

What changedVerificationGradle task / commandWhy
Any public API in published modules (core/, krpc/, grpc/, protobuf/, utils/)ABI compatibilitycheckLegacyAbiEnsures binary compatibility is preserved for library consumers
Any Kotlin/Java source fileDetekt static analysisdetektCode quality. Does NOT fail the build, but check console output for new violations
Any published JVM or KMP module source (including commonMain)JPMS check:jpms-check:compileJavaVerifies Java module system compatibility. commonMain code compiles to JVM too
New/removed modules or KMP target changesArtifact validationShell: ./scripts/validate_published_artifacts.sh -sEnsures the published artifact list stays consistent
New/removed modules or KMP target changesPlatform tabledumpPlatformTable --no-configuration-cache then check git statusUpdates docs/pages platform table
gradle.properties in any moduleProperties syncupdateProperties then check git statusKeeps all module gradle.properties in sync with root
compiler-plugin/ sources or templatesCompiler plugin tests:tests:compiler-plugin-tests:test (use running_gradle_tests)Validates codegen and diagnostics
compiler-plugin/ CSM templatesCompiler version compatUse the verify-compiler-plugin-compatibility skillEnsures all supported Kotlin versions still compile
protoc-gen/ sources (any change)Protobuf conformancetests:protobuf-conformance:bufGenerateCommonMain then check git statusCodegen changes may affect conformance test output
protoc-gen/ sources (any change)Protobuf unit tests:tests:protobuf-unittest:test (use running_gradle_tests)Validates protobuf codegen correctness
protoc-gen/ sources (any change)Well-Known Types:protobuf:protobuf-wkt:bufGenerateCommonMain then check git statusCodegen changes may affect WKT generated code
protoc-gen/ sources (any change)Implicit importsShell: ./scripts/update_implicit_types.sh then check git statusKeeps protoc-gen implicit import list current
protobuf/protobuf-wkt/ sourcesWell-Known Types:protobuf:protobuf-wkt:bufGenerateCommonMain then check git statusRegenerates WKT code
krpc/ protocol wire format or serializationProtocol compat tests:tests:krpc-protocol-compatibility-tests:jvmTest (use running_gradle_tests)Ensures wire format backward compatibility
krpc/ any changeskRPC compat tests:tests:krpc-compatibility-tests:jvmTest (use running_gradle_tests)Ensures old/new API compatibility
JS/WASM npm dependency changes or Kotlin version updateYarn lock updatekotlinUpgradeYarnLock and/or kotlinWasmUpgradeYarnLockKeeps JS/WASM lock files in sync
tests/protobuf-conformance/**/known_failures.txtConformance known-failures:tests:protobuf-conformance:jvmTest (see conformance details)Removed entries must actually pass now; added entries must actually fail

Module-Specific Tests

After running the verification checks above, run tests for the specific modules you changed using the running_gradle_tests skill.

Prefer jvmTest for KMP modules -- if your changes are in commonMain only, jvmTest is the fastest way to validate them since common code compiles to all targets. Only run jsTest, wasmJsTest, or nativeTest if the change is target-specific or you want full coverage.

Examples:

  • Single test: task <module>:jvmTest --tests "TestClass.testMethod"
  • All JVM tests for a module (preferred for commonMain changes): task <module>:jvmTest
  • Target-specific: task <module>:jsTest, <module>:wasmJsTest, <module>:nativeTest

Common Scenarios

"I changed a public API in :core"

  1. Run checkLegacyAbi via running_gradle_builds -- if it fails, run updateLegacyAbi and commit
  2. Run detekt via running_gradle_builds -- check output
  3. Run :jpms-check:compileJava via running_gradle_builds
  4. Run :core:jvmTest via running_gradle_tests

"I modified the compiler plugin"

  1. Run :tests:compiler-plugin-tests:test via running_gradle_tests
  2. Use verify-compiler-plugin-compatibility skill for multi-version check

"I added a new published module"

  1. Run dumpPlatformTable --no-configuration-cache via running_gradle_builds then commit if changed
  2. Run ./scripts/validate_published_artifacts.sh --dump -s via shell then commit if changed
  3. Run updateProperties via running_gradle_builds then commit if changed
  4. Run checkLegacyAbi via running_gradle_builds
  5. Run :jpms-check:compileJava via running_gradle_builds

"I changed protobuf/gRPC code"

  1. Run :protobuf:protobuf-wkt:bufGenerateCommonMain via running_gradle_builds then commit if changed
  2. Run tests:protobuf-conformance:bufGenerateCommonMain via running_gradle_builds then commit if changed
  3. Run :tests:protobuf-unittest:test via running_gradle_tests
  4. Run ./scripts/update_implicit_types.sh via shell then commit if changed (if protoc-gen changed)
  5. Run checkLegacyAbi via running_gradle_builds
  6. Run relevant module jvmTest via running_gradle_tests

"I changed kRPC code"

  1. Run :tests:krpc-protocol-compatibility-tests:jvmTest via running_gradle_tests
  2. Run :tests:krpc-compatibility-tests:jvmTest via running_gradle_tests
  3. Run checkLegacyAbi via running_gradle_builds
  4. Run detekt via running_gradle_builds -- check output
  5. Run relevant module jvmTest via running_gradle_tests

"I updated the Kotlin version"

  1. Use verify-compiler-plugin-compatibility skill
  2. Run kotlinUpgradeYarnLock and kotlinWasmUpgradeYarnLock via running_gradle_builds
  3. Run checkLegacyAbi via running_gradle_builds -- API dumps may need updating
  4. Run :jpms-check:compileJava via running_gradle_builds
  5. Full test suite

"I only changed documentation"

  1. Verify Writerside markup is valid (CI will build it, not runnable locally)
  2. If you changed the changelog: run updateDocsChangelog via running_gradle_builds

References

  • Detailed verification guides (what each check does, failure recovery, edge cases): read references/verification-details.md — consult when a check fails or behavior is unclear
  • Troubleshooting: read references/troubleshooting.md — consult when verifications fail unexpectedly

Download now (ZIP)

Trending

Quiet since September.about the whole repository

Dec 2025: 2 mentionsJan 2026: 1 mentionFeb 2026: 0 mentionsMar 2026: 1 mentionApr 2026: 0 mentionsMay 2026: 1 mentionJun 2026: 2 mentionsJul 2026: 2 mentionsAug 2026: 0 mentionsSep 2026: 1 mentionOct 2026: 0 mentionsNov 2026: 0 mentions
Dec 2025Jun 2026Nov 2026
Mentions a month of the Kotlin/kotlinx-rpc repository that our weekly crawl found. There is no adoption data for this file yet.

Who's talking about Kotlin/kotlinx-rpc

The biggest 5 of 16 mentions linking to the repository that our crawl found. Each line is their own headline.

See all 16

Talked about on GitHub (16 times).

On GitHub · 16

11 more on GitHub

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.