Przejdź do treści
Biblioteka skilli
Programowanie · Przegląd i audyt

backend-code-review

/backend-code-review

Przegląda kod backendu jak doświadczony inżynier: PR-y, zapytania do baz, konsumentów Kafki i bezpieczeństwo, z werdyktem.

Repozytorium
my-skill ↗
Licencja
MIT
Ostatnia zmiana repozytorium
30.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 30.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Przegląda kod backendu jak doświadczony inżynier: PR-y, zapytania do baz, konsumentów Kafki i bezpieczeństwo, z werdyktem.

Oryginalny opis (EN)

Review backend code like a senior engineer. Use when asked to review a pull request, diff, service, controller, repository layer, database query, Kafka producer/consumer, security-sensitive change, or test coverage for backend work. Do NOT use for implementation help (backend-job / software-internship), endpoint contract design (api-design), or test-writing (backend-testing) - review produces verdicts and issue lists, not first drafts.

Jak działa

  1. Purpose
  2. When to use
  3. When not to use
  4. Context intake
  5. Workflow
  6. Adaptation rules
  7. Inputs needed
  8. Output contract
  9. Rules and constraints
  10. Quality checklist
Sekcje z nagłówków SKILL.md, w oryginale · 85 linii, 905 słów
Podgląd SKILL.md
---
name: backend-code-review
description: Review backend code like a senior engineer. Use when asked to review a pull request, diff, service, controller, repository layer, database query, Kafka producer/consumer, security-sensitive change, or test coverage for backend work. Do NOT use for implementation help (backend-job / software-internship), endpoint contract design (api-design), or test-writing (backend-testing) - review produces verdicts and issue lists, not first drafts.
version: 1.1.0
author: Sothy Eng
---

# Backend Code Review

## Purpose
Provide senior-engineer-grade review of backend code: catch correctness, security, performance, and operational issues; distinguish blocking problems from style preferences; leave the author with concrete, actionable improvements.

## When to use
- Reviewing a PR, diff, or a single file/module before it merges — for the backend part-time job, the internship team's code, or Sothy's own code.
- Focused review requests: "review this Kafka consumer", "check this migration", "is this auth logic sound?".
- Reviewing generated or AI-written backend code before it's committed.

## When not to use
- Designing an endpoint from scratch → `api-design`.
- Fixing a live bug → `backend-debugging`.
- Writing new tests → `backend-testing` (but identify test gaps here and route there).
- Planning deployment of the reviewed change → `backend-deployment`.

## Context intake
- Whose code and at what stakes: production at the part-time job, the internship team's repo, or personal/thesis code - strictness and tone differ accordingly.
Detect or confirm before starting (ask at most what is genuinely needed):
- Which context: one of the contexts defined in `docs/workflow-profile.md` ("Contexts")? Read `docs/active-context.md` first: if `Current` names a context set within the last day, use it, apply its rules, and do not ask. Otherwise fall back to the active roles and projects in `docs/workflow-profile.md`; ask when it could be two different contexts.
- What is the desired output: a plan, code, a review, tests, documentation, a deployment plan, or research notes? Confirm if ambiguous.

## Workflow
1. Read the my-skill plugin's `docs/workflow-profile.md`. If it is missing, contradicts this request, or was last updated more than ~3 months ago, confirm or update it with Sothy before applying any role, project, or stack assumptions.
2. Ask for missing code/context if needed; do not review in a vacuum.
3. Read for correctness first, then security, then performance, then error handling/observability, then readability/testability, then operational concerns (migrations, rollout, monitoring).
4. Classify each finding as **Blocking**, **Important**, or **Optional/Suggestion**.
5. For every meaningful issue, explain *why* it matters and provide a concrete improved code snippet — not vague advice.
6. Explicitly check security invariants: authz on every endpoint, input validation, injection risks, secrets in code/logs, unsafe deserialization, missing rate limits on expensive endpoints.
7. Identify test gaps: what is untested, what test type fits (unit/integration/contract — name it).
8. Summarize with an explicit verdict.
9. End with the handoff: for `request changes`, offer to route the fixes through `backend-testing` (missing tests) or the implementation skill for the correct context (`backend-job` / `software-internship`) — but do not start rewriting the code under this skill.

## Adaptation rules

- Production paths: severity ranked by blast radius; authz/money/data-deletion findings are blocking.
- Internship repos: same format, more "why" explanations - the review doubles as teaching.
- Personal/thesis code: additionally check dataset licensing, reproducibility, and secrets committed in notebooks/config.

## Inputs needed
- The code or diff itself (full file preferred over fragments for controllers/services).
- Context: framework + versions, purpose of the change, intended behavior.
- What changed and why (ticket description or one-liner).
- Review priority if stated: security, performance, correctness, or full sweep.
- Environment it will run in (prod/staging) and whether it touches migrations, auth, or money/data-deletion paths.

## Output contract
- **Summary** — what the change does, overall impression in 2–3 sentences.
- **Blocking issues** — must fix before merge; each with why + improved snippet.
- **Important improvements** — should fix soon; not merge-blocking.
- **Optional suggestions** — style/preference, explicitly non-blocking.
- **Security concerns** — even if none, state it.
- **Test gaps** — missing cases and suggested test types.
- **Recommended verdict** — `approve`, `request changes`, or `reject`, with one-line justification.

## Rules and constraints
- Be direct and specific; never padding or praise-filler. Constructive framing: issue → impact → concrete fix.
- Do not rewrite the entire codebase; review what's in front of you. Note systemic issues once, briefly.
- Never claim something is a bug without being able to explain the failure path.
- Do not invent author intent; if a choice might be deliberate ("maybe this is intentional"), flag as a question.
- Never repeat or expose secrets found in the diff; flag that they must be rotated and removed, not pasted back.
- Keep internship reviews appropriately humble and learning-oriented; keep backend-job reviews production-grade. If the context is ambiguous, ask which team's code this is.

## Quality checklist

- [ ] Every blocking issue has an explainable failure path + improved snippet.
- [ ] Security invariants checked and stated (even if clean).
- [ ] Explicit verdict: approve / request changes / reject, with one-line rationale.
- [ ] Test gaps named with the test type to add.

## Examples
1. **Request:** "Review this Spring Boot Kafka consumer for retry handling, idempotency, and DLQ behavior."
   **Behavior:** Check offset/commit ordering vs. processing, poison-pill handling, at-least-once vs. exactly-once assumptions, idempotency keys, DLQ retention/alerting. Output the full format with verdict `request changes` if a duplicate-write path exists.
2. **Request:** "Quick look at my PR adding a `GET /admin/users/export` endpoint."
   **Behavior:** Security-first pass: endpoint authorization/admin check, data exposure scope, rate limiting, streaming vs. full load, audit logging. Blocking issue if glue code trusts client-supplied user ID instead of the session, plus test gaps for authz.

## Lessons learned

Record improvements after real usage (maintained via ``continuous-improvement``). Format:

- ``<date>`` -- ``<what happened>`` -> ``<change made to this SKILL.md>``

(empty -- entries appear after real usage)

Wersje

RepozytoriumWynikLicencja
Ta strona · albkue/my-skill100MIT
langflow-ai/langflow100MIT
langgenius/dify90Apache-2.0

Migawka bazy z 13.11.2026 · wersja paczki 9df57e7f3c60 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100backend-testing
    Tworzy praktyczne testy backendu: jednostkowe, integracyjne, API, bazy, Kafki i kontraktowe, w odpowiednim frameworku.
  • 100kafka-producer-consumer
    Prawdopodobnie pomaga w pracy z producentami i konsumentami Kafka przy tworzeniu backendu i uruchamia się automatycznie przy takich zadaniach.
  • 100backend-debugging
    Diagnozuje awarie backendu metodą analizy przyczyn: błędy HTTP i bazy, Kafkę, Redis, autoryzację i opóźnienia.
  • 90senior-code-reviewer
    Ocenia kod jak doświadczony inżynier: szuka błędów, przypadków brzegowych, słabej czytelności, wydajności i utrzymywalności.
  • 100java-engineer
    Działa jako inżynier backendu Java: implementuje funkcje Spring Boot, REST API, mikroserwisy, operacje na bazie danych oraz warstwy serwisu i Repository, z Spring Cloud, MyBatis Plus, Redis i Kafka.
  • 100code-review-changes
    Przegląda zmiany w PR, MR lub diffie jak doświadczony inżynier, weryfikuje błędy i podaje numer linii oraz poprawkę.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.