Directory
‹ Back to apps

cadence

A disciplined workflow plugin for Cursor, Claude Code, et al.: propose-then-implement, tight feedback loops, and stack conventions across all projects and accounts.

What’s inside

34 skills
  • Skillasync-orm-relationsUse when writing async backend code that touches ORM related fields — eagerly prefetch them (`select_related`, `prefetch_related`, `selectinload`, `joinedload`); do not rely on lazy loading in async contexts.
  • Skillbreak-work-into-verifiable-stepsUse when planning a multi-file or multi-concern change — break it into small steps with explicit files, edits, and verification commands per step.
  • Skillcapture-learningsUse after shipping a change, fixing a non-trivial bug, or finishing a debugging session — name one durable lesson the next session would benefit from knowing.
  • Skillcentralized-query-optionsUse when adding server-state queries or mutations (TanStack Query, SWR, RTK Query, Apollo) — define options in a centralized factory module; do not write inline keys at call sites.
  • Skillclean-commitsUse when committing or pushing — keep diffs surgical, exclude unrelated changes, and verify the local branch matches the named target before pushing.
  • Skillcomplete-refactorsUse when renaming, moving, or restructuring code — update every call site, test, fixture, and reference in the same change; no compat aliases or follow-up TODOs.
  • Skilldelegate-with-fresh-contextUse when a subtask is self-contained or parallelizable — delegate it to a fresh subagent with a precise brief instead of dragging conversation context forward.
  • Skilldont-apply-migrationsUse when making backend schema changes — generate the migration but stop short of applying it against any shared or production database.
  • Skillexplicit-undefinedUse when typing data-shaped TypeScript fields or props — prefer `T | undefined` over `field?: T` so callers must reason about the missing case.
  • Skillfeature-local-by-defaultUse when placing new modules, components, hooks, or helpers — default to the feature folder that uses them; promote to shared only when a concrete second user exists.
  • Skillimports-at-topUse when writing import statements — keep them at the top of the file; do not drop imports inside functions or class methods to work around typing or ordering issues.
  • Skillinvestigate-before-fixingUse when a bug, failing test, or unexpected behavior appears — trace the root cause before patching the symptom; cap hypothesis attempts at three before surfacing.
  • Skillkeep-files-focusedUse when files grow past a few hundred lines or accumulate unrelated responsibilities — split by concern rather than adding to the large file.
  • SkillloopUse for any non-trivial change to move it through the seven-phase engineering loop — think, plan, build, review, test, ship, reflect.
  • Skillmanage-context-windowUse during long sessions to avoid context degradation — read narrowly, delegate heavy reads, checkpoint progress, and hand off rather than push through polluted context.
  • Skillnamed-exportsUse when adding TypeScript modules — prefer named exports; avoid `export default` except where a framework explicitly requires it.
  • Skillnever-edit-generated-codeUse when generated code (OpenAPI clients, GraphQL types, protobuf, migrations, etc.) looks wrong — change the source schema or template and regenerate, never hand-edit the output.
  • Skillno-any-no-castsUse when writing or reviewing TypeScript code that would otherwise reach for `any` or `as` to silence the type checker — find the real type instead.
  • Skillno-hacking-central-infraUse when a backend test or eval fails — fix it at the edges (test, fixture, feature code); do not modify central settings, base classes, middleware, or shared fixtures to make it pass.
  • Skillno-placeholder-sentinelsUse when modeling lifecycle or state — represent distinct conceptual states with explicit enums or unions instead of collapsing them onto "", 0, None, or null.
  • Skillnullable-equalityUse when writing TypeScript nullability checks — prefer `== null` / `!= null` to match both null and undefined; use strict equality everywhere else.
  • Skillpercent-style-loggingUse when writing Python log calls — pass format args as separate parameters (`logger.info("...%s", value)`); do not pre-format with f-strings, which breaks log aggregator grouping.
  • Skillprefer-generated-api-clientUse when making a frontend backend call — go through the project's generated/typed API client; never reach for raw `fetch` or `axios` when a typed client exists.
  • Skillprefer-project-local-rulesWhen project-local rules or skills contradict this plugin on the same topic, follow the project-local rule and mention the conflict once.
  • Skillpromote-recurring-learningsUse when a captured lesson keeps recurring — decide whether to promote it into a project rule/skill or a Cadence PR; never auto-commit new rules.
  • Skillpropose-then-implementUse when the user asks for changes, code, or fixes — investigate first, present 1–3 ranked options, and wait for an explicit approval verb before editing files or running non-readonly tools.
  • Skillreact-compilerUse when writing or reviewing React 19 components with the Compiler enabled — default to no manual `useMemo` / `useCallback` / `React.memo`; reach for them only when referential identity genuinely matters.
  • Skillregister-models-in-adminUse when adding a new backend ORM model in a framework with a built-in admin UI (Django, Rails, Strapi, Payload, etc.) — register the model with a minimal usable configuration, or document why not.
  • Skillrun-lint-and-typecheckUse after editing source code — run the project's linter and type checker and fix anything you introduced before declaring done.
  • Skillself-review-before-handoffUse before declaring a change ready for review — read your own diff like a stranger, surface scope drift and completeness gaps, and calibrate claims with quoted evidence.
  • Skilltests-first-by-defaultUse when adding new behavior or fixing a bug — write the failing test first, watch it fail for the right reason, then write the minimal code to pass.
  • Skilltheme-tokens-onlyUse when writing frontend styles — pull colors, spacing, typography, radii, and shadows from the design system's theme tokens; no raw hex/RGB or magic pixels.
  • Skillupdate-callers-on-contract-changesUse when changing a shared contract — function signature, schema field, union variant, dispatch key — update every caller, test, fixture, and snapshot in the same change.
  • Skillverify-with-runtimeUse before declaring any change done — produce fresh runtime evidence from the actual system; stale evidence is not evidence.