Skip to content
Back to search

backend-kotlin-skill

MarketplaceWorks with Claude CodeGitHub

A Claude Code plugin with a gated waterfall SDLC skill for Kotlin backends built with Ktor: phase gates, templates, verified code patterns, handoff and baseline hooks, and an autopilot mode.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/phongmanh--backend-kotlin-skill/badge.svg)](/listings/phongmanh--backend-kotlin-skill)

HTML

<a href="/listings/phongmanh--backend-kotlin-skill"><img src="/api/listings/phongmanh--backend-kotlin-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

/plugin marketplace add phongmanh/backend-kotlin-skill
/plugin install backend-kotlin-skill@backend-kotlin-skill

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 16 lines
  1. {
  2. "name": "backend-kotlin-skill",
  3. "owner": {
  4. "name": "Manh Nguyen"
  5. },
  6. "metadata": {
  7. "description": "A Claude Code plugin with a gated waterfall SDLC for Kotlin backends built with Ktor."
  8. },
  9. "plugins": [
  10. {
  11. "name": "backend-kotlin-skill",
  12. "source": "./",
  13. "description": "A waterfall SDLC skill for Ktor backends, with the SDLC baseline-gate and session-handoff hooks and an autopilot mode."
  14. }
  15. ]
  16. }
README.md · README · 68 lines
  1. # backend-kotlin-skill
  2. A Claude Code plugin for building Kotlin backends with Ktor phase by phase, with a gated waterfall lifecycle: requirements, architecture, detailed design (API contract and schema), implementation, testing, deployment and operations. Each phase produces reviewed deliverables from fixed templates, and the next phase starts only after an explicit sign-off.
  3. ## Install
  4. ```
  5. /plugin marketplace add phongmanh/backend-kotlin-skill
  6. /plugin install backend-kotlin-skill@backend-kotlin-skill
  7. ```
  8. ## Skill
  9. | Skill | For | Run |
  10. |---|---|---|
  11. | `backend-kotlin-sdlc` | A Kotlin backend service or API feature built with Ktor: hexagonal layers, Resources routing, Koin, Exposed + PostgreSQL + Flyway, RFC 9457 problem details, JWT/OIDC, rate limiting, contract-first OpenAPI with breaking-change checks, structured logging, Micrometer + OpenTelemetry, OWASP ASVS and API Top 10, `testApplication` + Testcontainers, zero-downtime deploys | `/backend-kotlin-skill:backend-kotlin-sdlc` |
  12. Claude also picks the skill on its own when you ask it to plan, design, build, test or deploy a Ktor service, a REST API or a mobile backend that way. It bundles phase guides, references (architecture, API design, code patterns, security and privacy, performance and reliability, deployment and operations, testing, a PR review checklist) and deliverable templates.
  13. The deliverables live in your project under `docs/sdlc/<initiative-slug>/`, with `STATUS.md` as the control file: phase, gate log, risks, change requests, the current phase plan and the session handoff. The OpenAPI contract lives with the code (e.g. `docs/api/openapi.yaml`), because CI checks the code against it; it's frozen at G3.
  14. **With a mobile app.** The app can follow the same lifecycle with the [mobile-skill](https://github.com/phongmanh/mobile-skill) plugin, in its own repository and workspace. Each side lists the other's contract and requirements as inputs in `STATUS.md`, and each RTM cites the other side's IDs with a prefix (e.g. `APP-FR-007` here, `BE-FR-002` in the app).
  15. ## Hooks
  16. | Hook | Event | What it does |
  17. |---|---|---|
  18. | `session-context.py` | `SessionStart` | For each `docs/sdlc/*/STATUS.md`, shows the current phase, the next open row of the newest `## Phase N plan` and the `## Handoff` section. A session can start after `/clear` and pick up where the last one stopped. |
  19. | `guard-sdlc-baseline.py` | `PreToolUse` (`Edit`, `Write`, `MultiEdit`) | Asks you to confirm before Claude edits a deliverable that `STATUS.md` marks Approved. A baselined document changes only through an approved change request. |
  20. Only you can switch the baseline gate off, in your git-ignored `.claude/settings.local.json`:
  21. ```json
  22. { "env": { "SDLC_GATE": "off" } }
  23. ```
  24. If you also have `mobile-skill` enabled in the same project, both plugins register these hooks, so the session context shows twice and a baselined edit asks twice. Enable one plugin per project.
  25. ## Autopilot
  26. Runs the workflow unattended: `scripts/autopilot.py` starts a fresh headless session (`claude -p`) for each row of the current `## Phase N plan`, and the `session-context.py` hook hands each one the last handoff. Gates still stop: autopilot never records a sign-off.
  27. Do scope and the first phase plan interactively, then ask Claude to "run autopilot", or run it yourself from the project root. The script is in the installed plugin (`~/.claude/plugins/cache/backend-kotlin-skill/backend-kotlin-skill/<version>/scripts/`) or your clone of this repo:
  28. ```
  29. python3 <plugin>/scripts/autopilot.py --workspace docs/sdlc/<slug> --dry-run
  30. python3 <plugin>/scripts/autopilot.py --workspace docs/sdlc/<slug> --budget-usd 20
  31. ```
  32. | It stops when | Then you |
  33. |---|---|
  34. | The Handoff's **Waiting on user** isn't "nothing" (e.g. `G1 sign-off`, an SLO decision, a CR approval) | Decide or sign off in an interactive session, set it back to "nothing", re-run |
  35. | The next plan row is `Blocked: <reason>` | Unblock it, re-run |
  36. | Phase 4 with code review mode *Approve before writing* | Switch to *Review after writing*, or continue interactively |
  37. | A session fails, changes nothing in STATUS.md, or ends with `AUTOPILOT-RESULT: stop` | Read the reason and the log |
  38. | `--max-sessions` (default 20) or `--budget-usd` is reached | Re-run when ready |
  39. - **Permissions.** Sessions run with `--permission-mode acceptEdits` and allow file tools, `./gradlew`, `oasdiff` and local git (`status`, `diff`, `log`, `branch`, `switch`, `checkout -b`, `add`, `commit`). They deny `git push`, merges, rebases, hard resets, `gh` and `AskUserQuestion`. The baseline gate's confirm becomes a denial. Your project's `.claude/settings.json` allow list still applies.
  40. - **Phase 4.** One branch and commit per PR row, stacked on the previous one after lint, tests, the coverage floor and the contract check pass. Keep Docker running: the integration tests use Testcontainers. You push, open and review the PRs, and you deploy.
  41. - **Log.** One JSON line per session (time, session ID, plan item, cost, result) in `.claude/autopilot/<slug>.jsonl`; consider git-ignoring `.claude/autopilot/`.
  42. ## Optional: the SDLC rule
  43. Plugins can't ship rule files. `rules/sdlc.md` restates the document rules (IDs, baselines, the frozen contract, gate decisions, handoff format) and loads only while Claude edits `docs/sdlc/**`. To use it, copy it into your project as `.claude/rules/sdlc.md`.
  44. ## Development
  45. Run the hook and autopilot tests from the repo root:
  46. ```
  47. python3 -m unittest discover -s hooks/test
  48. python3 -m unittest discover -s scripts/test
  49. ```
  50. Check the plugin and the marketplace with `claude plugin validate .`.
  51. ## License
  52. MIT. See [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.