adr-roadmap

Generate phased implementation roadmaps from Architecture Decision Records with Mermaid diagrams.

16|3|Updated Nov 10, 2025
One-click install
npx skills add https://github.com/vladm3105/aidoc-flow-framework --skill adr-roadmap
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: adr-roadmap
Source: https://github.com/vladm3105/aidoc-flow-framework/tree/main/.claude/skills/adr-roadmap
Command: npx skills add https://github.com/vladm3105/aidoc-flow-framework --skill adr-roadmap

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill transforms scattered Architecture Decision Records (ADRs) into clear, phased implementation roadmaps, providing timelines, dependencies, and risk assessments to streamline project execution and ensure architectural alignment.

Core Features & Use Cases

  • ADR Analysis & Dependency Mapping: Automatically parse ADRs, identify inter-dependencies, and map critical paths to understand architectural relationships.
  • Phased Roadmap Generation: Decompose projects into logical phases with estimated durations, resource allocation, and comprehensive risk assessment.
  • Mermaid Diagram Visualization: Generate intuitive dependency graphs and Gantt charts in Mermaid format for clear visual communication of the roadmap to all stakeholders.
  • Use Case: For a complex microservices migration, use this skill to analyze all migration ADRs and generate a phased roadmap, complete with timelines, resource needs, and identified risks, ensuring a smooth and predictable transition.

Quick Start

Use the adr-roadmap skill to create an implementation roadmap from ADRs in '/opt/data/project/docs/ADR/' for a 'Trading platform, 5 FTE, 6-month timeline'.

Frequently Asked Questions about adr-roadmap

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I generate a phased implementation roadmap from Architecture Decision Records?

Architecture Decision Records (ADRs) can be transformed into phased implementation roadmaps by analyzing dependencies, estimating timelines, and decomposing work into logical phases. This Skill parses ADRs, identifies critical paths, and produces Mermaid diagrams and task lists with effort and risk estimates for execution planning.

Can I create dependency maps and timeline estimates from multiple ADRs across different domains?

Yes. This approach analyzes ADRs spanning web, mobile, data, ML, and infrastructure domains simultaneously. It computes inter-dependencies, generates critical path analysis, applies complexity and risk scoring, and produces visual dependency graphs and Gantt charts to show how decisions relate across domains.

What's the best way to visualize ADR dependencies and deployment phases?

Mermaid diagrams provide intuitive visual representation of ADR relationships and phased execution. This Skill generates both dependency graphs and Gantt charts in Mermaid format, enabling clear communication of roadmap structure, timelines, and resource allocation to all stakeholders.

How do I translate architectural decisions into executable deployment plans with risk assessment?

By applying dependency mapping, complexity scoring, and risk assessment to ADRs, you can decompose architectural decisions into phased tasks with resource allocation and risk buffers. This produces actionable implementation tasks with timeline estimates and identified mitigation strategies.

Can I use this approach for complex microservices migrations with multiple architectural decisions?

Yes. For migration projects with numerous ADRs and cross-domain dependencies, this approach generates comprehensive roadmaps including timelines, resource needs, critical path analysis, and risk assessments. It ensures predictable execution and architectural alignment throughout the transition.

What input format do ADRs need to be in for roadmap generation?

ADRs should be stored as structured documents (typically Markdown) in a dedicated directory. The Skill parses ADR metadata and decision content to extract dependencies, domains, and complexity signals, then computes phased decompositions and produces Mermaid artifacts and implementation task outputs.