dna

Interactive conversation for deliberate truth changes. Acts as a truth guardian that searches DNA, surfaces conflicts, debates proposals, and only applies changes with explicit human reasoning. Use via text or voice mode in Claude Code.

Assembles DNA truth artifacts into a self-contained specification that an autonomous agent can execute against without further human guidance. Use when handing off a well-defined deliverable to an agent for extended autonomous execution.

Consults DNA truth artifacts during task planning to understand system identity before designing an implementation approach. Use at the start of any non-trivial task before choosing an architecture or decomposing work into steps. Searches for intents, contracts, and constraints that shape the solution space.

Creates escalation artifacts that define when an agent should stop autonomous work and involve a human. Use when encoding decision boundaries for agent autonomy -- the guard rails on what agents can decide alone.

Creates tradeoff artifacts that encode which concern wins when competing concerns clash. Use when two valid goals, constraints, or intents conflict and agents need to know which to prioritize.

Stores truth artifacts in DNA with correct kind, format, metadata, and semantic context. Use when codifying decisions, contracts, intents, or constraints that should persist across code changes, team transitions, and framework evolutions.

Validates a proposed implementation plan against DNA truth artifacts to catch conflicts before any code is written. Use after forming an approach but before beginning implementation. Checks contracts, constraints, and evaluations against each planned step.

Registers and organizes label keys in DNA. Use when adding new metadata dimensions for filtering artifacts, or when setting up a new project with custom label keys.

Performs semantic and filtered searches across DNA truth artifacts. Use when looking for relevant decisions, constraints, or contracts before implementing features, resolving ambiguity, or understanding why something works the way it does.

Creates algorithm artifacts that describe computation logic without binding to a specific implementation. Use when codifying formulas, pricing rules, scoring logic, or any computation where the logic itself is the truth, independent of the code that implements it.

Creates constraint artifacts that set hard limits on what is acceptable -- performance bounds, security requirements, architectural boundaries. Use when establishing guardrails that must not be violated regardless of implementation approach.

Creates contract artifacts that define boundaries between components -- what they promise, what they expect, and what they explicitly exclude. Use when establishing or documenting how services, modules, or systems interact.

Creates evaluation artifacts that define what success means with testable criteria. Use when establishing acceptance criteria, invariants, or verification benchmarks that determine whether an implementation is correct.

Creates intent artifacts that capture WHY a system works the way it does. Use when codifying a decision about system behavior, a business rule, or a design principle that should survive code changes and framework evolutions.

Queries DNA truth artifacts before modifying a specific file or component. Use before any code change to verify it does not conflict with established intents, contracts, or constraints. Lighter-weight than full plan validation -- operates at the individual change level.

Registers and organizes custom artifact kinds in DNA. Use when the built-in template kinds do not cover a domain concept, or when setting up a new project with custom truth categories.

Reviews current code or proposed changes against stored DNA truth artifacts to identify violations, drift, and uncovered areas. Use after implementation to verify alignment with intents, contracts, and constraints, or during audits to assess truth coverage.