lubochka

assumption-registry

Make assumptions visible and testable. Use during planning, architecture adaptation, and unclear requirements.

authority-chain

Resolve which instructions win when rules conflict. Use at the start of every task and whenever instructions disagree.

claim-verification

Verify claims before presenting them as facts. Use in final answers, reports, reviews, and architecture decisions.

code-examination

Understand local code before changing it. Use before implementation, refactoring, test fixes, or architecture changes.

code-execution

Run commands safely and intentionally. Use before executing build, test, lint, generation, migration, deploy, or cleanup commands.

code-request-safety

Check risk before code actions. Use before running commands, editing files, deleting files, moving data, or changing configuration.

debug-session

Package debugging work so another agent or human can resume it. Use for longer debugging tasks or handoffs.

decision-capture

Record important decisions and rationale. Use when selecting architecture, stack guide, adapter output, or release policy.

document-hierarchy

Avoid competing sources of truth. Use when adding, moving, or adapting docs.

documentation-sync

Keep documentation aligned with behavior. Use when changing workflows, commands, APIs, examples, or user-facing behavior.

e2e-test-matrix

Design end-to-end coverage across critical paths. Use for release readiness, user workflows, UI/API flows, and adapter validation.

Code & Development Listed

evidence-before-final

Prevent claiming completion without proof. Use before final responses, handoffs, releases, or review closure.

executor-cannot-self-finish

Separate execution from completion approval. Use when an agent both implements and reviews its own work.

failure-triage

Classify failures before changing implementation. Use after failed builds, tests, commands, or smoke checks.

Code & Development Listed

generated-code-review

Review generated code before trusting it. Use after AI-generated code, scaffolding, migration output, or copied snippets.

goal-delivery-completeness

Check that delivered work matches the user's goal. Use before final response, release, or handoff.

Testing & QA Listed

integration-testing

Verify boundaries between components. Use when behavior crosses services, modules, tools, adapters, or data formats.

no-secrets

Prevent publishing sensitive material. Use before commits, reports, examples, adaptation outputs, and release.

output-readability-gate

Keep outputs readable for humans. Use before delivering plans, reports, READMEs, reviews, and adaptation output.

plan-before-execution

Create a bounded plan before non-trivial work. Use for multi-file, high-risk, ambiguous, or delegated work.

project-rules-first

Ensure project-specific rules are read before meaningful action. Use at task startup, before editing files, running commands, or adapting skills.

review-fix-loop

Close actionable feedback through repeated review and repair. Use after plan review, code review, content review, or release-gate review.

root-cause-tracing

Find the cause behind a symptom. Use when a failure repeats, appears indirect, or has multiple possible causes.

scope-and-blockers

Keep scope and blockers explicit. Use when requirements are broad, ambiguous, or blocked by missing information.

session-output-contract

Make session output useful, complete, and resumable. Use at handoff, final response, or long-running task summary.

stale-baseline-guard

Avoid acting on outdated context. Use after interruptions, long sessions, branch changes, or concurrent edits.

systematic-debugging

Make debugging reproducible and disciplined. Use for unclear failures, regressions, or unstable behavior.

test-integrity

Keep tests meaningful and honest. Use when writing, changing, disabling, or interpreting tests.

user-journey-testing

Validate work through a realistic user path. Use for UX, tool workflows, onboarding, and generated instructions.