Backend Atomic Commit Skill

When to Use This Skill

Use this Skill in backend/Django repos (especially the Diversio monolith backend) when you want:

• /backend-atomic-commit:pre-commit – to actively fix the current code (formatting, imports, type hints, logging, etc.) so that it matches:
  • Local AGENTS.md / CLAUDE.md rules.
  • .pre-commit-config.yaml expectations.
  • .security/ diff helpers (ruff and local imports).
  • Monty’s backend taste.
• /backend-atomic-commit:atomic-commit – to run the same checks plus:
  • Enforce that the staged changes are atomic (one coherent change).
  • Ensure all quality gates are green (no shortcuts).
  • Propose a strict, ticket-prefixed commit message without any Claude or AI signatures.
• /backend-atomic-commit:commit – to run atomic-commit, then create the commit once all gates are green (no bypassing commit-msg hooks).

Example Prompts

• “Run /backend-atomic-commit:pre-commit on this repo and actively fix all files in git status so they obey backend AGENTS.md, .pre-commit-config.yaml, .security/* helpers, and Monty’s taste (no local imports, strong typing, structured logging). Then summarize what you changed and what’s still [BLOCKING].”
• “Use /backend-atomic-commit:atomic-commit to prepare an atomic commit for the staged changes in backend/. Enforce all pre-commit hooks and .security scripts, run Ruff, active type gate checks, Django checks, and relevant pytest subsets, then propose a ticket-prefixed commit message with no AI signature and clearly mark any [BLOCKING] issues.”
• “Treat my current backend changes as one logical bugfix and run /backend-atomic-commit:pre-commit in a strict mode: eliminate local imports, fix type hints (no Any, no string-based annotations), clean up debug statements, and ensure Ruff, .security/local_imports_pr_diff.sh, active type gate checks, and Django checks are happy."
• “Before I commit these optimo_* changes, run /backend-atomic-commit:atomic-commit --auto to:
  • enforce structured logging with TypedDict payloads,
  • ensure no PII in logs,
  • verify tests and .security/* scripts, and then tell me whether the commit is ready and what the commit message should be.”
• “Use /backend-atomic-commit:commit to run all gates on my staged changes, then create the commit once everything is green. If something fails, keep fixing and re-running until it commits or you have a clear [BLOCKING] reason it can’t.”

If you’re not in a backend repo (no manage.py, no backend-style AGENTS.md, no .pre-commit-config.yaml), this Skill should say so explicitly and fall back to a lighter “generic Python pre-commit” behavior.

Modes

This Skill behaves differently based on how it is invoked:

• pre-commit mode – invoked via /backend-atomic-commit:pre-commit:
  • Actively applies changes to make the working tree and staged files conform to repo standards and pre-commit requirements.
  • Runs all relevant static checks and auto-fixers.
  • Does not propose or drive a commit.
• atomic-commit mode – invoked via /backend-atomic-commit:atomic-commit:
  • Runs everything from pre-commit mode.
  • Enforces atomicity of staged changes.
  • Requires all gates to be green.
  • Proposes a commit message, but must never add AI signatures or plugin branding to the message.
• commit mode – invoked via /backend-atomic-commit:commit:
  • Runs everything from atomic-commit mode.
  • Creates the commit once all gates are green.
  • Must still never add AI signatures or plugin branding to the message.

The command markdown sets the mode. You should detect the mode from the command description/context and adjust behavior accordingly.

Core Priorities

Emulate Monty’s backend engineering and review taste, tuned for pre-commit:

1. Correctness & invariants – multi-tenancy, time dimensions, and security constraints come first.
   • Never eyeball date/time math (day-of-week, "yesterday", timezone edges). Always verify using date +%Y-%m-%d or Python datetime — never compute dates manually. Date calculation errors have been a recurring friction point in real sessions.
2. Safety & reviewability – avoid dangerous schema changes, large risky try/except blocks, hidden PII, or untyped payloads.
3. Atomic commits – one commit should represent one coherent change; split unrelated work.
4. Local repo rules first – treat AGENTS.md and CLAUDE.md as the source of truth when present; this Skill is a default baseline.
5. Tooling alignment – use uv wrappers, .security/* helpers, and .pre-commit-config.yaml hooks as documented, not ad-hoc commands.
6. Type and structure – prefer precise type hints, TypedDict/dataclasses, and structured logging over untyped dicts and log soup.
7. No AI signatures in commits – commit messages must look like a human wrote them; this Skill should be invisible from git log.

Always prioritize [BLOCKING] issues over style and nits.

Environment & Context Gathering

When this Skill runs, you should first gather context using Bash, Read, Glob, and Grep:

• Git context:
  • git status --porcelain
  • git branch --show-current
  • git diff --cached --stat
  • git diff --cached --name-only
  • git log --oneline -10
• Repo configuration:
  • Read AGENTS.md and CLAUDE.md (if present) for repo-specific rules.
  • If they’re missing or obviously stale, recommend generating/canonicalizing them so linting/workflow rules are persistent (AGENTS.md canonical, CLAUDE.md as a minimal stub that sources it).
  • Detect .pre-commit-config.yaml.
  • Detect .security/ scripts, especially:
    • ./.security/gate_cache.sh
    • ./.security/ruff_pr_diff.sh
    • ./.security/local_imports_pr_diff.sh
  • Detect manage.py / Django project layout.
• Tool availability:
  • uv and .bin/ wrappers:
    • .bin/ruff, .bin/ty, .bin/pyright, .bin/mypy, .bin/django, .bin/pytest.
  • Fallback to uv run or plain python / pytest / ruff where necessary.
  • Read local typing policy docs when present (for example: docs/python-typing-3.14-best-practices.md, TY_MIGRATION_GUIDE.md) and follow them over this default.

If the repo clearly isn’t the Diversio backend / Django4Lyfe style, say so and adjust expectations (but you can still run generic Python pre-commit checks).

Gate cache behavior (when available)

If ./.security/gate_cache.sh exists, treat it as the canonical wrapper for heavy deterministic checks. Use it by default for type gates and Django checks.

./.security/gate_cache.sh --gate ty-check --scope index -- .bin/ty check .
./.security/gate_cache.sh --gate django-system-check --scope index -- uv run python manage.py check --fail-level WARNING

Use scope=index for commit-focused gating and scope=working when results are expected to depend on unstaged edits. Do not bypass cache unless explicitly requested or debugging:

CHECK_CACHE_BUST=1 ./.security/gate_cache.sh --gate ty-check --scope index -- .bin/ty check .
./.security/gate_cache.sh --clear-this-checkout

For Ruff/local-import diff helpers, call the scripts directly. They already use cache-aware execution internally and include local staged/unstaged tracked files. Prefer running them through pre-commit hooks first; call scripts directly only for targeted diagnosis or when a matching hook is missing/disabled.

Checks in Both Modes

In both pre-commit and atomic-commit modes, follow this pipeline:

1. Scope changed files

• Start from files reported by git status and git diff --cached:
  • Distinguish staged vs unstaged vs untracked.
• Categorize by type:
  • Python (src vs tests; optimo_*, dashboardapp, survey, etc.).
  • Templates (Django HTML).
  • Config (YAML, JSON, .pre-commit-config.yaml, pyproject.toml, requirements*.txt).
  • Docs/markdown.

2. Run pre-commit first (primary execution path)

   • If .pre-commit-config.yaml exists, run hooks on the intended file set before any direct per-tool commands.
   • atomic-commit mode:
     • run on staged files only:

     pre-commit run --files $(git diff --cached --name-only --diff-filter=ACMR)
     

   • pre-commit mode:
     • run on modified tracked + untracked files:

     CHANGED_FILES="$(
       {
         git diff --name-only --diff-filter=ACMR
         git ls-files --others --exclude-standard
       } | sed '/^$/d' | sort -u
     )"
     pre-commit run --files $CHANGED_FILES
     

   • If pre-commit already executed a gate successfully, do not rerun the same gate directly in the same pass.

3. Direct command fallback (targeted, non-duplicative)

   • Run direct commands only when:
     • a corresponding hook failed and you need focused diagnosis/fix loops, or
     • the repository does not expose that gate via pre-commit hooks.
   • Keep fetch behavior strict by default (fail closed); only allow CHECKS_ALLOW_FETCH_SKIP=1 when a local skip is explicitly acceptable.
   • For Ruff/local-import helpers, direct invocation is:
     • ./.security/ruff_pr_diff.sh
     • ./.security/local_imports_pr_diff.sh
   • These helpers intentionally evaluate the union of origin/<base>..HEAD, staged, and unstaged tracked Python changes.

4. Type checking with active repository gate (ty-first)

   • Detect the type gate in this order (unless repo docs/CI explicitly differ):
     • ty if configured ([tool.ty], ty.toml, .bin/ty, or CI/pre-commit).
     • Else pyright if configured.
     • Else mypy if configured.
   • Run the active checker on modified Python files only during iteration when the type hook is not already covered/passing via pre-commit:

     # ty example - staged files (atomic-commit mode):
     .bin/ty check $(git diff --cached --name-only --diff-filter=ACMR | grep '\.py$')
     
     # ty example - all modified files (pre-commit mode):
     .bin/ty check $(git diff --name-only --diff-filter=ACMR | grep '\.py$')
     
     # pyright example - staged files (atomic-commit mode):
     .bin/pyright $(git diff --cached --name-only --diff-filter=ACMR | grep '\.py$')
     
     # pyright example - all modified files (pre-commit mode):
     .bin/pyright $(git diff --name-only --diff-filter=ACMR | grep '\.py$')
     
     # mypy example - staged files (atomic-commit mode):
     .bin/mypy $(git diff --cached --name-only --diff-filter=ACMR | grep '\.py$')
     
     # mypy example - all modified files (pre-commit mode):
     .bin/mypy $(git diff --name-only --diff-filter=ACMR | grep '\.py$')
     

   • Scoped checks are for speed only; if the repo/CI requires a wider check before merge/commit, run that gate before final "ready" verdict.
   • IMPORTANT: For any file you touch, you must resolve ALL active type-check errors in that file—not just the ones you introduced. If CI checks modified files, pre-existing errors in touched files will still cause failures. Do not dismiss errors as "pre-existing" if the file is in your diff.
   • Common pitfall: Fixing ruff ARG002 (unused argument) by prefixing with _ may satisfy ruff but break ty if the method signature must match a parent class (e.g., Django admin methods). Always run both checks together.
   • Treat any active type-check errors in modified files as [BLOCKING] for atomic-commit mode or [SHOULD_FIX] for pre-commit mode.

5. Django system checks

   • If Django check hook already passed via pre-commit, do not rerun directly.
   • Otherwise run through cache wrapper when present:
     • ./.security/gate_cache.sh --gate django-system-check --scope index -- uv run python manage.py check --fail-level WARNING
   • If wrapper is missing, run .bin/django check or equivalent:
     • uv run python manage.py check --fail-level WARNING.
   • For risky changes (models, migrations, core logic), run targeted pytest subsets based on changed apps:
     • Example: dashboardapp/ changes → pytest dashboardapp/tests/.
   • If tests cannot be run (e.g. env not set up), say so explicitly and treat “tests not run” as at least [SHOULD_FIX] and often [BLOCKING] for atomic-commit.

6. Interaction with pre-commit hooks

   • If .pre-commit-config.yaml exists:
     • Expect hooks to run and modify files (ruff, djlint, interrogate, custom scripts).
     • After hooks run, re-check git status and restage modified files as appropriate.
   • If a hook executable is missing (e.g. check_prepare_commit_msg_hook.py referenced but not present), do not crash:
     • Record a [SHOULD_FIX] issue stating which hook is missing and why it matters.

7. Convergence loop (do not stop early)

   • Treat the pipeline above as iterative, not one-shot.
   • You are not done until:
     • The relevant pre-commit hooks pass, and
     • Ruff/type-gate/djlint/Django checks you ran are green, and
     • The index/working tree is stable (hooks are no longer rewriting files).
   • Use a tight fix → rerun loop:
     1. Re-run the smallest scoped failing check on the relevant files.
     2. Fix only the reported file(s).
     3. Re-run the same check until it passes.
     4. Only then advance to the next gate.
   • Prefer rerunning only failing hooks/checks on the same file scope, then escalate to wider runs only if required by repo policy.
   • If hooks modify files, always re-check git status and restage only the intended files (atomic commits should not accidentally grow).

   Iteration budgets

   • Per-check limit: Do not attempt to fix the same check failure more than 3 times with the same approach. If the same error (or substantively identical error) reappears after 3 real fix attempts, that check is stuck.
   • Total pipeline limit: Do not run more than 10 full pipeline passes across the session. After 10, stop and report.

   Stuck detection

   You are stuck on a check when any of these are true:

   • The same error message reappears after you applied a fix for it (your fix is not working or is being reverted by another tool).
   • A fix for one tool breaks another in a cycle (e.g., djlint reformats → ruff flags → you fix → djlint re-reformats the same spot).
   • You have exhausted the 3-attempt per-check budget.

   When stuck:

   1. Stop attempting that specific fix.
   2. Report it as [BLOCKING] with:
      • The exact error.
      • What you tried (briefly).
      • Why it is not resolving (tool conflict, unfamiliar pattern, etc.).
   3. Continue fixing other unrelated issues if any remain.
   4. In final output, clearly separate "Fixed" from "Stuck / Needs Human".

   No TodoWrite for this pipeline

   Do not use TodoWrite or TaskCreate to track individual gate results. This is a fixed, known sequence — not an open-ended task list. Tracking ruff/ djlint/type-check failures as todo items wastes tokens and context window. Report results directly in the final output using the existing severity-tagged sections (Checks run, Needs changes, etc.).

Monty Backend Taste – Auto-Fix Rules

When running in pre-commit mode, you are allowed and expected to actively edit code to align with Monty’s backend taste where it is clearly safe. In atomic-commit mode, you may still fix things, but be more conservative and always summarize edits.

Imports & local imports

• Enforce no local imports at any cost:
  • Avoid from myapp.models import MyModel inside functions or methods just to dodge cyclic imports.
  • Use .security/local_imports_pr_diff.sh as the first line of defense.
  • Prefer:
    • Module-level imports.
    • Refactoring helpers to avoid cycles.
    • Type-only imports (e.g. from __future__ import annotations) when needed.
  • If moving imports risks true cyclic import problems:
    • Suggest structural changes (splitting modules, relocating helpers).
    • Never silently reintroduce local imports; call out unresolved cycles as [SHOULD_FIX].

Logging (especially in optimo_* apps)

• Enforce structured logging:
  • Prefer structured payloads over single log strings:
    • Good: logger.info("optimo_event", extra={"company_uuid": str(company.uuid)}).
    • Avoid: logger.info("Company %s did %s", company.name, something).
  • In optimo_* apps, treat unstructured logging as at least [SHOULD_FIX].
• PII in logs:
  • Never log PII such as assignment.employee.email; this is enforced by pre-commit hooks already, but you should also conceptually check.
  • Prefer logging UUIDs/IDs instead of emails or names.
• Log levels:
  • Avoid logger.exception for expected error paths; use error or warning with explicit messages.

Try/except and error handling

• Avoid large, catch-all try/except blocks:
  • Shrink the try body to only the lines that can raise.
  • Replace bare except: or except Exception: with specific exceptions whenever possible.
• Never swallow exceptions silently:
  • Always log or re-raise; returning silently on failure is [BLOCKING] for behaviorally important code.
• Avoid overusing getattr/hasattr as a crutch:
  • Only use hasattr() when truly needed (e.g. cross-version adapters) and document why.

Types, hints, and data structures

• Be pedantic about type hints:
  • Avoid Any as much as possible; prefer precise types and generics.
  • No string-based type hints like "OptimoRiskQuestionBank"; use real types and proper imports.
  • Add missing annotations on new/changed functions, especially in optimo_*, dashboardapp, and other core apps.
• Prefer structured data:
  • Replace Dict[str, Any] or ad-hoc dict payloads with TypedDict or dataclasses when the shape is stable and local.
  • Avoid shape-changing dicts where keys appear/disappear across branches; suggest a typed structure instead.

Tests and fixtures

• Avoid repeating fixtures or introducing fixture collisions:
  • Prefer existing rich fixtures described in AGENTS.md (e.g. responses in survey tests, company/survey fixtures that respect multi-tenant relationships).
  • Do not introduce new Django TestCase classes in optimo_* apps; use pytest + fixtures.
  • Watch for multi-tenant fixture mismatches (e.g. survey from one company, user from another); highlight these as [BLOCKING] when they affect correctness.
• When touching tests:
  • Prefer pytest fixtures and helper factories.
  • Avoid local imports inside tests; use module-level imports.

ORM and query patterns

• Use reverse relations where it reduces imports and improves clarity:
  • Prefer company.surveys.all() to Survey.objects.filter(company=company) when it avoids extra imports and is idiomatic.
• Watch for N+1 queries in obvious loops:
  • Flag them as [SHOULD_FIX] for hot paths or performance-sensitive code.

Commented / dead code and debug artifacts

• Remove obvious debug leftovers:
  • print(...), pdb.set_trace(), ipdb.set_trace(), breakpoint() in non-test code.
• Remove clearly obsolete commented-out blocks:
  • Old versions of code commented around a new implementation.
• For ambiguous commented sections:
  • Flag them as [SHOULD_FIX] and suggest either deleting them or moving rationale into docs.
• TODO / FIXME without ticket IDs:
  • Suggest converting to ticket-tagged comments (e.g. TODO(GH-123): ... or TODO(27pfu0): ...) or moving the note into ClickUp.

String / formatting style

• Migrate to f-strings where it improves clarity:
  • Replace old % formatting or .format() with f-strings when not blocked by translation/i18n constraints.
• Avoid giant f-strings with logic:
  • Suggest splitting into intermediate variables when readability suffers.

Django templates and djlint

• Treat template lint failures (djlint + template pre-commit hooks) as first-class problems, not “formatting nits”. In atomic-commit mode, they are usually [BLOCKING].
• Common djlint blockers (fix patterns):
  • Inline styles (style="..."):
    • Prefer CSS classes / existing utility frameworks.
    • If new styling is required, add it via the repo’s normal CSS pipeline (not ad-hoc inline styles).
  • Unnamed endblocks:
    • If templates use named blocks, always close them with the name:
      • {% block content %} ... {% endblock content %}
    • Do not leave bare {% endblock %} when the repo’s linting expects names.
• Workflow:
  • After any template edit, run the relevant template hooks (or djlint --lint --check <file> when that’s what the repo uses), fix, and re-run until clean.
  • If hooks auto-reformat templates, accept the changes and restage the file.
• Optional acceleration (Claude Code):
  • Recommend an afterEdit hook for *.html in .claude/settings.json to run djlint on the edited file, using the repo's wrapper (.bin/djlint, uv run djlint, etc.) when available.
• Configuration discovery:
  • Look for [tool.djlint] in pyproject.toml or a standalone .djlintrc file for project-specific settings (profile, indent, max_line_length, custom rules, ignored rules). Respect these when they exist.
  • If no djlint config is found but djlint hooks are in .pre-commit-config.yaml, note this as [SHOULD_FIX] — the project should have explicit djlint configuration to avoid ambiguity.
• Reformat-first protocol:
  • Always run djlint --reformat (or the repo's reformat hook) before running djlint --lint --check. Reformatting resolves most lint issues automatically.
  • After reformatting, re-stage the modified templates (git add <file>) before running the lint check.
  • If the lint check still fails after a fresh reformat, the remaining errors are structural (missing attributes, banned patterns) and must be fixed by hand.

Security & secrets

• Detect obvious secrets checked into code or fixtures:
  • Hardcoded tokens, passwords, API keys.
  • Flag as [BLOCKING] and suggest using environment variables and 1Password.
• Avoid staging obvious secret-heavy files:
  • .env, google_creds.json, google_drive_creds.json, etc.
  • Recommend un-staging and .gitignore updates where appropriate.

Migrations and schema changes

• Do not change migration behavior automatically; instead:
  • Detect destructive schema changes (dropping fields/tables) combined with code changes that still expect those fields:
    • Mark as [BLOCKING] and recommend a two-step rollout:
      • PR 1: remove usage in code, keep schema.
      • PR 2: drop the field/table once code is clean.
  • Detect new non-nullable fields with defaults on large/hot tables:
    • Mark as [SHOULD_FIX] or [BLOCKING] depending on risk.
    • Suggest the safer pattern:
      • Add nullable field with no default.
      • Backfill in batches.
      • Then add default for new rows only.
  • Detect volatile defaults (UUIDs, timestamps) used in migrations:
    • Warn against backfilling large tables inside a single atomic migration; recommend batched or non-atomic backfills.

Critical backend patterns from AGENTS.md

• Watch for new instances of patterns explicitly banned in backend AGENTS.md:
  • Django Ninja Query() module-level constants that break parameter resolution (e.g. Q_INCLUDE_INACTIVE = Query(False, ...)).
  • Legacy survey models like OptimoEmployeeSurvey or employee_survey.
  • Any other CRITICAL warnings spelled out in that file.
• Treat any new usage of these patterns as [BLOCKING].

Atomic-Commit Mode – Extra Strictness

In atomic-commit mode (invoked via /backend-atomic-commit:atomic-commit), you must be very strict:

1. Atomicity of staged changes

   • From git diff --cached --name-only, determine if staged changes belong to one coherent change:
     • Example of non-atomic:
       • Refactor in survey/ plus an unrelated optimo bugfix and docs tweak.
   • Emit:
     • [BLOCKING] if the staged set is clearly multiple logical changes.
     • [SHOULD_FIX] for minor opportunistic cleanups that could be split.
   • You may suggest a split (e.g. “extract the optimo fix into a separate commit”) but must not label a non-atomic set as “ready”.

2. All gates must be green

   • The commit is not ready if any of these fail:
     • ./.security/ruff_pr_diff.sh
     • ./.security/local_imports_pr_diff.sh
     • .bin/ruff check / ruff format
     • active type gate on staged Python files (ty/pyright/mypy)
     • .bin/django check / manage.py check
     • Relevant pytest subsets for risky changes
     • Pre-commit hooks defined in .pre-commit-config.yaml
   • A passing pre-commit hook execution counts as satisfying the matching gate. Do not require duplicate direct-command reruns unless diagnosing failures.
   • Where available, heavy gates should run via ./.security/gate_cache.sh instead of ad-hoc direct invocation.
   • In --auto style usage, you may skip conversational confirmation, but you must not relax these gates.
   • If tests or checks are skipped for any reason, clearly state that and treat it as at least [SHOULD_FIX] and usually [BLOCKING].

3. Commit message generation (no AI signature)

• Extract ticket ID from branch name using repo conventions:
  • For the Diversio backend:
    • Branch name: clickup_<ticket_id>_...
    • Commit format per AGENTS.md: <ticket_id>: Description.
  • If commit message hooks like commit_msg_hook.py exist:
    • Avoid double-prefixing ticket IDs.
    • If hooks and docs disagree, call that out as [SHOULD_FIX] and follow the documented AGENTS.md convention for suggestions.
• Generate a concise, human-looking subject line:
  • Summarize what changed and why in one line.
  • Do not mention Claude, AI, this Skill, or plugin names.
• Do not add any footer or signature:
  • No “via Claude Code”.
  • No “Generated by backend-atomic-commit”.
  • Commit messages must look like a human wrote them.

4. Final preview and verdict

Your atomic-commit output should include:

• A short summary of what was checked.
• Checks run – listing each gate and its status.
• What’s aligned – strengths and good patterns in the staged changes.
• Needs changes – bullets with [BLOCKING], [SHOULD_FIX], [NIT].
• Proposed commit – suggested commit message and list of files.
• An explicit verdict:
  • “✅ Commit ready” only if there are no [BLOCKING] items.
  • Otherwise:
    • “❌ Not ready to commit” with concrete next steps.

You should never encourage the user to run git commit as-is if any [BLOCKING] issues remain.

Pre-Commit Mode – Fixing Without Committing

In pre-commit mode (invoked via /backend-atomic-commit:pre-commit):

• You may aggressively auto-fix:
  • Formatting, linting, local imports, obvious type hints, logging patterns, removal of debug code, and consistent fixtures.
• You must:
  • Run the same gates described above (Ruff, .security/*, active type gate, Django checks, tests as appropriate).
  • Re-run or re-stage files modified by tools or hooks.
• You do not propose a commit or check atomicity.
• Your output should focus on:
  • Fixes applied – concrete edits you made.
  • Remaining issues – with severity tags.
  • Checks run – which gates passed/failed.

This mode is the “make my working tree clean and standards-compliant” helper before running an atomic commit.

Severity Tags & Output Shape

Always structure findings using severity tags and sections:

• [BLOCKING] – must be fixed before a commit is considered ready:
  • Failing .security scripts or pre-commit hooks.
  • New banned patterns from AGENTS.md (e.g., Ninja Query constants, legacy survey models).
  • Obvious multi-tenant or security regressions.
  • Non-atomic staged changes in atomic-commit mode.
• [SHOULD_FIX] – important, strongly recommended changes:
  • Style/structure that harms readability or maintainability.
  • Missing type hints where types are clear.
  • Ambiguous commented code or TODOs without tickets.
  • Missing tests for non-trivial new behavior.
• [NIT] – minor cleanups:
  • Docstring tone/punctuation.
  • Minor naming and formatting nits not covered by Ruff.

Output shape for both modes:

• 1–3 sentence summary of what was checked.
• Sections (when appropriate):
  • What’s aligned
  • Needs changes
  • Checks run
  • Proposed commit (only in atomic-commit mode)

Be direct, specific, and actionable in each bullet, pointing to file/area and suggesting concrete corrections. Never hide behind vague "consider improving" phrases when you can be precise.

Compatibility Notes

This Skill is designed to work with both Claude Code and OpenAI Codex.

• Claude Code: install the corresponding plugin and use its slash commands (see plugins/backend-atomic-commit/commands/).
• Codex: install the Skill directory and invoke name: backend-atomic-commit.

For installation, see this repo's README.md.