kibana-py

Use when wiring a project's dev workflow (local stack, test tiers, gates, docs), or when naming make targets in a repo that has siblings — build a thin self-documenting Makefile facade over real scripts, name targets from the shared cross-repo vocabulary, and split env files by owner so targets consume them but never write them.

Use when you need to prove a feature actually delivers its intended outcome to a user or caller, not just that its code paths run — write executable acceptance tests against real, observable outcomes, derived from the spec before or independent of the implementation.

Use when adding any new capability to a working system — ship it behind a flag or optional collaborator that defaults to prior behavior.

Use when a spec, plan, or implementation must be independently reviewed before it is trusted, committed, or advanced to the next phase — dispatch a fresh reviewer per named lens whose job is to refute the artifact, not confirm it.

Use when building automation that edits, tests, or deploys itself — an agent that regenerates its own code, a self-updating pipeline, any loop that modifies the thing running it.

Use when about to call any integration, deployment, or hard guarantee "done" — prove it live end-to-end and capture the run as evidence.

Use when a value (project id, model, threshold, rubric) would be duplicated across Makefile, scripts, docs, and code — collapse to one source.

Use when a decision, gotcha, or preference would otherwise be re-derived next session — capture it as an indexed note, then verify before trusting stale ones.

Use when about to claim work is complete, shippable, or ready to release or tag a milestone — run a script that reads declared criteria and emits GO/NO-GO instead of asserting completion from memory; the author never self-certifies.

Use when shipping or handing off code — treat docs as a first-class deliverable: present-tense, diagrammed-as-code, verified against reality, reader-tested.

Use when a spec or plan is about to depend on a dependency, library, API, CLI, or platform whose real behavior you have not personally observed — run a small real experiment before trusting docs or memory, and let the observed result outrank documentation when they disagree.

Use when the human's request rests on a premise you can check, or contradicts evidence or a recorded principle — challenge once with evidence before complying; their decision still wins.

Use when an LLM or agent emits decisions or claims and you need to turn fuzzy output into a verifiable, regression-protected signal.

Use when building an app that touches external systems (LLMs, DBs, cloud SDKs, HTTP APIs) — isolate a framework-free core behind ports a linter enforces.

Use when a live result contradicts the hoped-for story or a metric could be gamed — state what really works and never fake a green.

Use when fanning out many write-capable sub-agents across one build — pre-wire the shared seams, own files disjointly, namespace shared state, and re-run every agent's gate yourself.

Use when an agent or automation can touch external systems — stay read-only/reversible by default and gate consequential acts behind durable human approval.

Use when handling credentials, IaC, or ephemeral cloud — make secrets un-committable, grant least privilege, tear down to zero, own only your scope.

Use when starting any non-trivial feature or project, or when docs and code have drifted — write the design chain before or alongside code and reconcile specs onto reality.

Use when containing untrusted or agent-generated execution, sandboxing a worker with write/exec tools, or judging whether a guard is actually a security boundary.

Use when editing code, configs, or docs — make the smallest correct diff, checkpoint before risky work, and write commits that justify themselves.