Skip to content
OpenAgentSkill
Browsing is open · Catalog captured 2026-11-21 · Automatic updates and account services are paused.
Development

ddd

Use DDD for coding tasks: discover the official documentation needed for the requested behavior, maintain application knowledge, plan with cited decisions, implement, and compare code and explanations against the sources. Also use when resuming work or debugging unexpected behavior that challenges an implementation assumption.

ddd-methodology · Static checks on file

Installation

Read the source and dependencies before running a command. Copying does not install or execute anything.

npx skills add romiluz13/mifal --skill ddd

About this skill


name: ddd description: > Use DDD for coding tasks: discover the official documentation needed for the requested behavior, maintain application knowledge, plan with cited decisions, implement, and compare code and explanations against the sources. Also use when resuming work or debugging unexpected behavior that challenges an implementation assumption. license: MIT compatibility: Install together with sibling skills ddd-scope, ddd-ground, and ddd-verify; their reference files are reached by relative path. metadata: author: ddd-methodology version: "0.8.0"

Documentation-driven development

Ask: What must be true for this change to work, and where can I verify it? Use the agent's existing file, search, browsing, and execution tools. The agent owns research, the task note, and verification; the user supplies the outcome. Before coding, save the source-backed plan; include snippets when they clarify a consequential choice. After coding, read the resulting code and explanations and reopen supporting material before recording the comparison. These are tool actions, not statements that research or comparison happened.

Follow existing authorization. Plan-only ends with a saved plan; review-only reports findings without editing application code or application documentation. Authorized implementation continues through corrections and checks without another routine approval stage. DDD owns this sequence; use other skills for technical guidance within the same authorization, not to insert conflicting workflows or routine approval stages. Apply explicit write restrictions to documentation too. For no-file-change requests, provide the note inline and state that it was not saved. A source, test, or declared assumption is not proof of perfect code.

1. Inspect the task and its surroundings

Read the request, project instructions, and relevant existing plan. On a resumed task, reload this skill if its instructions are no longer in context. Locate the existing task plan (including orchestration plans) or matching .ddd/notes/ note and read it before research or edits. Before reusing its research or editing, read the current dependency/version files or query the runtime; compare them and the current code with the note. Do not rely on the note's old version alone.

On adoption, inspect existing documentation, structure, configuration, and version locations. Reuse the documentation entry point; if none serves this purpose, use docs/README.md, extending it if present. Start with a small map: purpose, major components and flows, technology/version locations, existing explanations, and known limits. Link it from existing project guidance when adoption edits are authorized. This is orientation, not whole-application research. Keep explanations there initially; split only when useful. Adopt existing projects incrementally; old task notes need no bulk migration.

Before researching, find explanations by affected behavior and component through that entry point, alongside the task note. Check them against current code, requirements, and actual versions. Greenfield descriptions remain visibly proposed until implemented and checked; untouched areas stay outside the verified scope. For compact examples of adoption and maintenance, see application knowledge.

Follow the requested behavior through the affected code and callers. Inspect relevant contracts, configuration, tests, and existing project decisions. Resolve actual dependency and runtime versions; a manifest range is not an installed version. Resolve lockfile/environment differences before choosing versioned APIs.

Turn what you find into concrete questions: which behavior or constraint must hold, which component supplies it, and what could invalidate it? At each changed connection between components, check the data passed and ownership of completion, errors, permissions, state, and resource lifetime. Include accessibility and operational constraints when relevant. Include language/standard-library rules when correctness depends on them, such as async execution, mutation, or conversion. Cover both sides of a changed connection: for example, a database row's shape and lifetime as well as the web framework's JSON conversion. An existing helper does not establish the guarantees of the technology it wraps.

Finish inspection with the questions needed to plan this task. For possible omissions or difficult version resolution, consult where to look. Use its categories selectively; do not inventory unrelated dependencies or manufacture missing diagrams.

2. Research the questions that matter

Preflight the research surfaces before grounding the plan: with one cheap check each, confirm the available tools can reach what this task needs, official indexes, web search, or shipped local material. An unreachable surface moves the affected question to the fallback below, not the whole task: try the other reachable official routes for it first. Plan with an unresolved question open instead of spending the research budget on retries.

Open supplied links. Find missing official sources through web search or official indexes and read the applicable sections before finalizing a technology-dependent plan. Search-result snippets and remembered URLs are not source reads. Prefer the actual version; use official release notes, tagged source, or shipped docs/types for missing details. Keep existing dependency versions unless an upgrade is authorized. For unversioned services, record the API revision when available and access date. For each technology question in the plan, read its supporting section before coding. A library/language name is not a source: record the URL or local file and section actually read. If support is missing, mark the question open instead of writing a remembered guarantee into the note.

Match authority to the question: requirements and accep

Read the complete source ↗