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
Markdown
[](/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
- {
- "name": "backend-kotlin-skill",
- "owner": {
- "name": "Manh Nguyen"
- },
- "metadata": {
- "description": "A Claude Code plugin with a gated waterfall SDLC for Kotlin backends built with Ktor."
- },
- "plugins": [
- {
- "name": "backend-kotlin-skill",
- "source": "./",
- "description": "A waterfall SDLC skill for Ktor backends, with the SDLC baseline-gate and session-handoff hooks and an autopilot mode."
- }
- ]
- }
README.md · README · 68 lines
- # backend-kotlin-skill
- 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.
- ## Install
- ```
- /plugin marketplace add phongmanh/backend-kotlin-skill
- /plugin install backend-kotlin-skill@backend-kotlin-skill
- ```
- ## Skill
- | Skill | For | Run |
- |---|---|---|
- | `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` |
- 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.
- 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.
- **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).
- ## Hooks
- | Hook | Event | What it does |
- |---|---|---|
- | `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. |
- | `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. |
- Only you can switch the baseline gate off, in your git-ignored `.claude/settings.local.json`:
- ```json
- { "env": { "SDLC_GATE": "off" } }
- ```
- 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.
- ## Autopilot
- 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.
- 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:
- ```
- python3 <plugin>/scripts/autopilot.py --workspace docs/sdlc/<slug> --dry-run
- python3 <plugin>/scripts/autopilot.py --workspace docs/sdlc/<slug> --budget-usd 20
- ```
- | It stops when | Then you |
- |---|---|
- | 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 |
- | The next plan row is `Blocked: <reason>` | Unblock it, re-run |
- | Phase 4 with code review mode *Approve before writing* | Switch to *Review after writing*, or continue interactively |
- | A session fails, changes nothing in STATUS.md, or ends with `AUTOPILOT-RESULT: stop` | Read the reason and the log |
- | `--max-sessions` (default 20) or `--budget-usd` is reached | Re-run when ready |
- - **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.
- - **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.
- - **Log.** One JSON line per session (time, session ID, plan item, cost, result) in `.claude/autopilot/<slug>.jsonl`; consider git-ignoring `.claude/autopilot/`.
- ## Optional: the SDLC rule
- 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`.
- ## Development
- Run the hook and autopilot tests from the repo root:
- ```
- python3 -m unittest discover -s hooks/test
- python3 -m unittest discover -s scripts/test
- ```
- Check the plugin and the marketplace with `claude plugin validate .`.
- ## License
- MIT. See [LICENSE](LICENSE).
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.