Claude Cursor Skill

superior-database

Design, implement, review, or repair database schemas, queries, indexes, transactions, migrations, and backfills with explicit integrity and rollout constraints. Use when the datastore behavior or data lifecycle is a primary part of the task. Do not use for routine persistence ca

LLM Mart · 0 points · 2 views 0 listing impressions 0 install-command copies
Download kodekateam-superior-skills-skills_superior-database-325740f.zip · 7 KB

Install

skills CLI npx skills add https://github.com/KodekaTeam/superior-skills/tree/main/skills/superior-database
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install kodekateam-superior-skills@llmmart
Git git clone https://github.com/KodekaTeam/superior-skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole kodekateam/superior-skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Superior Database

Make data changes correct for the actual datastore, workload, and rollout environment. Preserve established migration tools and ownership boundaries; do not import generic database conventions without verifying engine behavior and repository practice.

Establish the data contract

Before changing a schema, query, or migration, determine:

  • datastore engine, version, topology, and relevant extensions;
  • authoritative schema and migration history;
  • entity ownership, identifiers, relationships, and tenant boundaries;
  • invariants that must hold at write time and read time;
  • expected cardinality, access patterns, ordering, and retention;
  • compatibility window across application versions, workers, and replicas;
  • data volume, traffic shape, lock sensitivity, and recovery expectations.

Inspect effective production constraints only through authorized, non-sensitive evidence. Do not assume local fixtures represent production volume, skew, nullability, or legacy states.

Design schema and queries together

Read references/schema-query-and-index-design.md when adding or changing tables, collections, fields, relationships, indexes, query shapes, pagination, or retention behavior.

  • Encode durable invariants in the datastore when the engine and rollout permit it.
  • Keep application validation for user feedback, but do not rely on it as the sole protection against concurrent or alternate writers.
  • Select indexes from real predicates, joins, ordering, uniqueness, and cardinality rather than indexing every filtered field.
  • Verify query semantics for nulls, collation, timezones, ordering ties, and empty sets.
  • Bound result sets and write batches; avoid hidden full scans, unbounded fan-out, and per-row queries.

Do not denormalize, partition, shard, or introduce a cache without demonstrated workload pressure and a clear consistency owner.

Preserve transactional truth

Read references/transactions-and-consistency.md when work spans related writes, concurrent actors, replicas, queues, caches, idempotency, or cross-service workflows.

  • Define the invariant and the exact boundary that must be atomic.
  • Use datastore guarantees deliberately; do not infer serialization from application request order.
  • Keep transactions short and avoid remote calls while holding locks unless the established architecture proves it safe.
  • Make retryable operations idempotent and distinguish transaction retry from business-operation replay.
  • Treat cache invalidation, replica lag, and event publication as explicit consistency contracts.

Plan migrations as deployments

Read references/safe-migrations-and-backfills.md for production-facing schema changes, constraint introduction, type changes, table rewrites, backfills, data repair, or removal of old representations.

  • Prefer compatibility-first expand, migrate, verify, and contract phases when multiple application versions may coexist.
  • Identify locks, rewrites, validation cost, replication impact, and failure recovery before execution.
  • Make backfills bounded, observable, resumable, and idempotent where practical.
  • Define verification and rollback or forward-recovery behavior before destructive or irreversible steps.
  • Never run a production migration, destructive query, broad data correction, or shared-environment load test without explicit authorization and the intended environment.

A migration file compiling locally is not evidence that its production execution is safe.

Verify the result

Use the repository's existing database and test tooling. Verify proportionately:

  • migration applies from the supported previous state and reaches the intended schema;
  • rollback works when it is promised and semantically possible;
  • old and new application versions behave according to the compatibility plan;
  • constraints reject invalid states and preserve valid legacy data;
  • representative queries return correct results with stable ordering;
  • query plans and runtime behavior are checked against representative shape and scale when performance is in scope;
  • backfill counts, checkpoints, error handling, and reruns preserve invariants.

Report commands actually run, datastore/version used, data scale represented, and conditions not exercised. Never claim zero downtime without evidence for the relevant engine, topology, workload, and deployment sequence.

Combine skills narrowly

  • Use superior-logic for domain behavior, API contracts, and application orchestration around persistence.
  • Use superior-testing when migration, integration, compatibility, or concurrency test design is a primary concern.
  • Use superior-debugging when a data symptom exists but its causal mechanism is uncertain.
  • Use superior-performance when representative query, capacity, resource, or latency measurement is a primary concern.
  • Use superior-reliability when replication, availability, failover, backup objectives, or recovery readiness is primary.
  • Use superior-delivery when migrations must be coordinated with artifact promotion, rollout, or rollback.
  • Use superior-api-security for tenant isolation, unsafe query construction, sensitive-data exposure, or abuse-driven resource controls.
  • Use superior-docs after verified schema, migration, recovery, or operational procedure changes.

Do not broaden a focused database change into a datastore replacement, ORM rewrite, or infrastructure migration without explicit scope.

Files (superior-skills)
  • references
    • safe-migrations-and-backfills.md 3.1 KB
      Loading…
    • schema-query-and-index-design.md 3.1 KB
      Loading…
    • transactions-and-consistency.md 2.9 KB
      Loading…
  • SKILL.md 5.8 KB
    ---
    name: superior-database
    description: Design, implement, review, or repair database schemas, queries, indexes, transactions, migrations, and backfills with explicit integrity and rollout constraints. Use when the datastore behavior or data lifecycle is a primary part of the task. Do not use for routine persistence calls whose schema and consistency contracts are unchanged.
    ---
    
    # Superior Database
    
    Make data changes correct for the actual datastore, workload, and rollout environment. Preserve established migration tools and ownership boundaries; do not import generic database conventions without verifying engine behavior and repository practice.
    
    ## Establish the data contract
    
    Before changing a schema, query, or migration, determine:
    
    - datastore engine, version, topology, and relevant extensions;
    - authoritative schema and migration history;
    - entity ownership, identifiers, relationships, and tenant boundaries;
    - invariants that must hold at write time and read time;
    - expected cardinality, access patterns, ordering, and retention;
    - compatibility window across application versions, workers, and replicas;
    - data volume, traffic shape, lock sensitivity, and recovery expectations.
    
    Inspect effective production constraints only through authorized, non-sensitive evidence. Do not assume local fixtures represent production volume, skew, nullability, or legacy states.
    
    ## Design schema and queries together
    
    Read [references/schema-query-and-index-design.md](references/schema-query-and-index-design.md) when adding or changing tables, collections, fields, relationships, indexes, query shapes, pagination, or retention behavior.
    
    - Encode durable invariants in the datastore when the engine and rollout permit it.
    - Keep application validation for user feedback, but do not rely on it as the sole protection against concurrent or alternate writers.
    - Select indexes from real predicates, joins, ordering, uniqueness, and cardinality rather than indexing every filtered field.
    - Verify query semantics for nulls, collation, timezones, ordering ties, and empty sets.
    - Bound result sets and write batches; avoid hidden full scans, unbounded fan-out, and per-row queries.
    
    Do not denormalize, partition, shard, or introduce a cache without demonstrated workload pressure and a clear consistency owner.
    
    ## Preserve transactional truth
    
    Read [references/transactions-and-consistency.md](references/transactions-and-consistency.md) when work spans related writes, concurrent actors, replicas, queues, caches, idempotency, or cross-service workflows.
    
    - Define the invariant and the exact boundary that must be atomic.
    - Use datastore guarantees deliberately; do not infer serialization from application request order.
    - Keep transactions short and avoid remote calls while holding locks unless the established architecture proves it safe.
    - Make retryable operations idempotent and distinguish transaction retry from business-operation replay.
    - Treat cache invalidation, replica lag, and event publication as explicit consistency contracts.
    
    ## Plan migrations as deployments
    
    Read [references/safe-migrations-and-backfills.md](references/safe-migrations-and-backfills.md) for production-facing schema changes, constraint introduction, type changes, table rewrites, backfills, data repair, or removal of old representations.
    
    - Prefer compatibility-first expand, migrate, verify, and contract phases when multiple application versions may coexist.
    - Identify locks, rewrites, validation cost, replication impact, and failure recovery before execution.
    - Make backfills bounded, observable, resumable, and idempotent where practical.
    - Define verification and rollback or forward-recovery behavior before destructive or irreversible steps.
    - Never run a production migration, destructive query, broad data correction, or shared-environment load test without explicit authorization and the intended environment.
    
    A migration file compiling locally is not evidence that its production execution is safe.
    
    ## Verify the result
    
    Use the repository's existing database and test tooling. Verify proportionately:
    
    - migration applies from the supported previous state and reaches the intended schema;
    - rollback works when it is promised and semantically possible;
    - old and new application versions behave according to the compatibility plan;
    - constraints reject invalid states and preserve valid legacy data;
    - representative queries return correct results with stable ordering;
    - query plans and runtime behavior are checked against representative shape and scale when performance is in scope;
    - backfill counts, checkpoints, error handling, and reruns preserve invariants.
    
    Report commands actually run, datastore/version used, data scale represented, and conditions not exercised. Never claim zero downtime without evidence for the relevant engine, topology, workload, and deployment sequence.
    
    ## Combine skills narrowly
    
    - Use `superior-logic` for domain behavior, API contracts, and application orchestration around persistence.
    - Use `superior-testing` when migration, integration, compatibility, or concurrency test design is a primary concern.
    - Use `superior-debugging` when a data symptom exists but its causal mechanism is uncertain.
    - Use `superior-performance` when representative query, capacity, resource, or latency measurement is a primary concern.
    - Use `superior-reliability` when replication, availability, failover, backup objectives, or recovery readiness is primary.
    - Use `superior-delivery` when migrations must be coordinated with artifact promotion, rollout, or rollback.
    - Use `superior-api-security` for tenant isolation, unsafe query construction, sensitive-data exposure, or abuse-driven resource controls.
    - Use `superior-docs` after verified schema, migration, recovery, or operational procedure changes.
    
    Do not broaden a focused database change into a datastore replacement, ORM rewrite, or infrastructure migration without explicit scope.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.