# Eda

> Skill: Explainable by Design Architecture (EDA)

- Skill: `duclm1x1/eda` (Agent Skill)
- Install (CLI): `npx skillmds@latest add duclm1x1/eda`
- Raw SKILL.md: https://api.skillmd.com/api/skills/duclm1x1/eda/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: duclm1x1 (https://skillmd.com/u/duclm1x1)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/duclm1x1/eda

---

# Skill: Explainable by Design Architecture (EDA)

**Version:** 1.0
**Author:** Manus AI

---

## 1. Description

This skill implements an **Explainable by Design Architecture (EDA)**, a framework that forces the AI to document its reasoning *as* it makes architectural decisions. Instead of producing a "black box" of code, an AI using EDA generates a rich, human-readable log of every significant choice it makes—why it chose a specific database, why it selected a particular framework, and what alternatives it considered. This creates a transparent and auditable development process.

This skill is a direct implementation of the eighth of the 10 breakthrough LLM innovations.

### Key Features:

- **Built-in Transparency:** Makes explainability a core part of the architecture, not an afterthought.
- **Structured Decision Logging:** Provides a clear, consistent format for documenting every architectural choice.
- **Auditable Rationale:** Captures not just *what* the AI decided, but *why*, including the alternatives it rejected.
- **Human-Readable Reports:** Can generate a comprehensive report that explains the entire system architecture in plain English.

## 2. How to Use

### 2.1. Installation

This skill is a self-contained Python module. To use it, import the `ExplanationEngine` class.

```python
from skills.eda.src.eda_engine import ExplanationEngine
```

### 2.2. Logging Decisions

As the AI makes architectural choices during the development process, it should log them with the `ExplanationEngine`.

```python
eda = ExplanationEngine()

# The AI decides on a database
eda.log_decision(
    component="Database",
    decision="PostgreSQL",
    rationale="Chosen for its robustness, scalability, and strong support for JSON data types, which is ideal for flexible product catalogs.",
    alternatives=["MySQL", "SQLite"]
)

# The AI decides on a frontend framework
eda.log_decision(
    component="Frontend Framework",
    decision="React.js",
    rationale="Selected for its large ecosystem, component-based architecture, and performance. It is well-suited for building an interactive user experience.",
    alternatives=["Vue.js", "Angular"]
)
```

### 2.3. Retrieving Explanations

You can query the engine to get explanations for specific parts of the system.

```python
db_decisions = eda.get_explanations_for_component("Database")

for decision in db_decisions:
    print(f"Why did we choose {decision.decision}? Rationale: {decision.rationale}")
```

### 2.4. Generating a Full Report

At the end of the development process, you can generate a complete architectural decision record.

```python
full_report = eda.generate_report()
print(full_report)
```

## 3. Development Roadmap

EDA is fundamental to building trust in AI-generated software. Future development will focus on making the explanations richer and more integrated.

- **v1.1: Code-to-Decision Linking:**
    - **Goal:** When logging a decision, also include a reference to the specific code file(s) or function(s) that implement that decision. This will create a powerful link between the abstract rationale and the concrete implementation.
    - **Timeline:** 3 weeks

- **v1.2: Visualization of Decision Tree:**
    - **Goal:** Create a tool to visualize the decision-making process as a tree. This will make it easy to see how high-level choices cascade down into lower-level implementation details.
    - **Timeline:** 4 weeks

- **v1.3: Interactive Explanation Interface:**
    - **Goal:** Build a simple web interface where a human developer can click on a component in a diagram and see the full explanation for why it was designed that way.
    - **Timeline:** 6 weeks

- **v2.0: Proactive Explanation:**
    - **Goal:** The AI will learn to anticipate which parts of its design are most likely to be confusing to a human and will automatically generate more detailed explanations for those areas. It will move from simply logging decisions to actively teaching the user about its design.
    - **Timeline:** 8 weeks