Einordnung

AI frameworks compared: placing the Design-to-Code model

Anyone building AI-powered products or agents today finds a wide range of frameworks, guidelines, and development tools. They start from different places – from scientifically grounded guidelines for human-centered AI to concrete spec and coding workflows.

But how do these approaches differ in practice? And how well do they combine user-centricity, Human in the Loop, and technological implementation?

We compared a selection of approaches across ten criteria – from user-centricity and scientific grounding to technology-openness and scalability, all the way to concrete implementation from UX strategy to code.

In doing so, we also place our own Design-to-Code model (DtC): a UX-led approach that combines human-centered design with AI-powered implementation.

Ranking

Ranking 1 – AI-driven development of digital products and services

Rank	Framework	User-centered	Human in the Loop	Technology-open	Scientifically grounded	Practice-oriented	Scalable	End-to-End	Enterprise-proven	Design system as source of truth	Shared language	Points /50
1	Design-to-Code Framework	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓	45
2	ISO 9241-210	✓	–	✓	✓	–	◐	–	✓	–	◐	32
3	BMAD Method	◐	◐	✓	–	✓	◐	✓	–	–	–	31
3	Microsoft HAX Toolkit	✓	✓	✓	✓	–	–	–	✓	–	◐	31
5	Google PAIR Guidebook	✓	✓	✓	✓	–	–	–	◐	–	◐	30
6	Shneiderman HCAI	✓	✓	✓	✓	–	–	–	–	–	◐	29
6	GitHub Spec Kit	–	✓	✓	–	✓	◐	◐	◐	–	–	29
6	IBM Design for AI	✓	◐	✓	◐	–	–	–	✓	–	✓	29
9	AWS Kiro	–	◐	–	◐	✓	✓	◐	◐	–	–	27
10	AICAM	◐	◐	–	–	✓	✓	◐	–	◐	◐	26
11	Tessl	–	◐	◐	–	✓	✓	–	–	–	–	24

✓ met (4–5 points) · ◐ partially met (3 points) · – not or barely met (1–2 points)

The result: Theory frameworks fall short on implementation, implementation tools fall short on user focus. The Design-to-Code Framework is the only approach without a gap.

What does the comparison show?

The approaches examined pursue different goals and strengths. Guidelines and standards offer important foundations for human-centered AI design. Spec-driven approaches and development tools, on the other hand, mainly support concrete technical implementation.

The Design-to-Code model (DtC) connects these perspectives: it leads from UX strategy through scope, structure, skeleton, and surface to a working application, integrating Human-in-the-Loop, technology-openness, and a shared way of working for business, design, and development.

Above all, the comparison makes one thing visible: building good AI-powered products takes more than good theory or a capable tool alone. What matters is the connection between user-centricity, clear requirements, and concrete implementation.

Ranking 2 – Agent-based development of digital processes

Frameworks and methods for digital products and services

Framework / Method	Holistic approach	Iterative way of working	Scalability	Security
Design-to-Code (DtC) Framework	From UX strategy through scope, structure, skeleton, surface to code Shared language for business, design, and development	Low- and high-fidelity canvases sharpen requirements in loops Test interim results with users and adjust deliberately	Machine-readable design system as source of truth Requirements stay usable for further development	Defined approval points for humans and AI Compliance, data protection, and dev security considered in the enterprise context
Agentic Design Patterns	Architecture patterns for agent systems: routing, delegation, review loops Technology focus – UX and business phases missing	Start simple, extend patterns step by step Create–check–improve loop raises quality	Modular building blocks, combinable and extendable Add complexity only when needed	Guardrails and checks as patterns Human gates possible, GDPR not part of the approach
Design Thinking / Double Diamond	From understanding the problem to the solution: discover, define, develop, deliver Usually ends before technical implementation	Prototypes and user tests in short loops Deliberately opening up and narrowing down solutions	Method scales across teams No technical basis for growing the application	No dedicated focus Data protection and security must be added separately
Human-in-the-Loop Design	Focus on intervention points in the agent process Covers neither UX strategy nor implementation	Adjust intervention points based on field feedback Raise agent autonomy step by step	Approvals can become a bottleneck as usage grows Escalation rules needed	Core of the approach: humans decide on critical actions Basis for traceability and controlled handling of data
Jobs to Be Done – JTBD	Clarifies which job users want to get done Basis for strategy and scope, not for implementation	Keep re-testing interviews and hypotheses Continuously sharpen job stories	Jobs stay stable across individual features Aligns the roadmap long term	No security focus Mind data protection in interviews and data collection
Service Design / Service Blueprinting	The whole service landscape: frontstage, backstage, processes Bridge to technical implementation often missing	Refine journeys and blueprints in workshops and tests Changes become visible quickly	Makes dependencies and interfaces visible Helps plan operations and growth	Data flows and responsibilities visible in the blueprint Security and GDPR not checked systematically
Design Sprint + Rapid Prototyping	Five days from problem statement to tested prototype Only a slice, no path to production	Very fast learning through a user test at the end of the week Single sprints, not an ongoing routine	The prototype is a throwaway artifact Further development of the application not covered	Prototypes run on test data Security and data protection not addressed
Spec-Driven Development	From specification to code with AI agents UX focus and user-centricity usually not included	Spec, plan, tasks, implementation – changes go through the spec User testing not foreseen	Specs in the repository ease further development Depending on the tool, they go stale after the start	Reviews and rules possible GDPR and security depend on team and tool
Eval-driven development	Checks the quality of the agent process Does not replace a path from idea to implementation	Test cases make every change measurable Fast regression checks	Evals grow with the system Protect quality across model changes and growth	Errors and edge cases surface early Data protection must be respected in test data
NIST AI Risk Management Framework	Governance across the entire lifecycle: Govern, Map, Measure, Manage Not a design method	Recurring cycle for risk assessment No link to user testing	Applicable at organization level Processes for operation and further development	Strength: risks, accountability, transparency Profile for generative AI

★ Overall rating from 1 to 4 stars (4 = strongest coverage across all four dimensions). The row order is the ranking.

What does this comparison show?

No method covers all four dimensions – except the Design-to-Code Framework. Design Thinking, JTBD, Service Design, and Design Sprint are strong in user understanding and iterative testing, but end before implementation and leave scalability and security open.

Agentic Design Patterns, Spec-Driven Development, eval-driven development, and Human-in-the-Loop Design provide important technical building blocks and control points, but have no UX focus. The NIST AI Risk Management Framework adds governance and risk management, but is not a design method.

The Design-to-Code Framework combines UX strategy, iterative user testing, a scalable design system, and defined approval points in one continuous approach from idea to code.

The frameworks

Design-to-Code Framework – functional aesthetics+

UX-led framework that translates the five levels of user experience by Jesse James Garrett (strategy, scope, structure, skeleton, surface) into an AI-powered implementation pipeline. Independent of the design tool, from Figma to a self-hosted HTML design system. design-to-code.com/framework

ISO 9241-210+

International standard for human-centered design of interactive systems across the entire lifecycle. Describes principles and activities, but no concrete methods. Underpins, among others, the service standards of GOV.UK and the NHS.

BMAD Method+

Open-source method with specialized AI agents that guide you from brief through PRD and UX specification to architecture. Comprehensive, but with a high onboarding and token cost.

Microsoft HAX Toolkit+

18 guidelines for human-AI interaction, validated across multiple rounds, including with 49 design practitioners on 20 AI products. Explicitly not a checklist.

Google PAIR Guidebook+

Methods, best practices, and patterns for human-centered AI products, grounded in the experience of over a hundred Google employees, industry experts, and research. With its own chapter on feedback and control mechanisms.

Shneiderman HCAI+

Scientific model that pursues high human control and high automation at the same time. Influential for understanding Human in the Loop, but without implementation tools.

GitHub Spec Kit+

Open-source toolkit (MIT) that steers AI agents through a workflow from constitution to implementation and works with around 30 agents. Specifications mainly serve the starting point and become outdated afterward.

IBM Design for AI+

Guidelines and an ethics framework for AI design, embedded in Enterprise Design Thinking for Data and AI. Creates a shared language for design and development.

AWS Kiro+

AI development environment based on VS Code with a spec workflow. Specifications live permanently in the repository, but the environment ties you to AWS.

AICAM+

Cross-role open-source workflow for Claude Code with a Figma MCP pipeline in which design specifications take top priority. Tied to a single AI agent.

Tessl+

Commercial platform that treats specifications as durable infrastructure. Strong on ongoing development, without a UX focus.

Process modeling with BPMN + DMN+

Describes workflows, handoffs, and fixed business rules using the established OMG standards BPMN and DMN. Shows where rules are sufficient and where flexible AI handling may be worthwhile. omg.org/spec/BPMN

Agentic Design Patterns+

Helps choose a suitable architecture for the task: chained steps, routing, parallel processing, dynamic delegation, or a create-check-improve loop. anthropic.com/engineering/building-effective-agents

Context Engineering+

Gives the agent the right information at the right time: a concept for instructions, data access, tools, memory, and selecting relevant information. anthropic.com/engineering/effective-context-engineering-for-ai-agents

Human-in-the-Loop Design+

Deliberately builds human decisions and approvals into the agent process: defined intervention points set when the agent may act and when it must ask or hand off. reference.langchain.com · Human-in-the-Loop Middleware

Eval-driven development+

Checks the quality of the entire agent process using representative test cases and criteria for task success, tool use, errors, cost, and runtime. anthropic.com/engineering/demystifying-evals-for-ai-agents

NIST AI Risk Management Framework+

Governs responsibilities and risks across development and operation along Govern, Map, Measure, Manage, complemented by a profile for generative AI. nist.gov/itl/ai-risk-management-framework

The criteria

Foundations

User-centered
Human-centered design is a guiding principle, not a single phase.
Human in the Loop
People retain control and approval at defined points.
Technology-open
Independent of AI model and provider; the strongest lock-in is decisive.
Scientifically grounded
Based on published research or recognized standards.

Implementation

Practice-oriented
Directly helps build working applications.
Scalable
Supports the step-by-step evolution of existing applications.
End-to-End
Continuous from strategy to code.

Differentiation

Enterprise-proven
Used in corporate contexts with compliance and established systems.
Design system as source of truth
A machine-readable design system is the binding reference for implementation.
Shared language
Understandable and usable for business, design, and development.

Methodology

Ranking 1: Each framework was scored per criterion on a scale from 1 to 5; the sum produces the ranking (max. 50 points). The basis is the publications, standards, documentation, and market overviews listed in the sources below.

Ranking 2: The frameworks and methods were assessed qualitatively along four dimensions – holistic approach (from idea to implementation, UX and development), iterative way of working (agile practice with user testing and adjustments), scalability (lasting growth and further development of the application), and security (human gates, GDPR, dev security). This yields an overall rating of 1 to 4 stars; the row order is the ranking.

Both assessments are functional aesthetics' own judgment, not an independent benchmark. The figures for the Design-to-Code Framework are based on our own methodology and project experience with enterprise clients.

As of: October 2026

Sources

Foundations of human-centered design and AI

Garrett, J. J. (2011): The Elements of User Experience. User-Centered Design for the Web and Beyond. 2nd ed., New Riders.
Shneiderman, B. (2020): Human-Centered Artificial Intelligence: Reliable, Safe & Trustworthy. arxiv.org/abs/2002.04087
Shneiderman, B. (2022): Human-Centered AI. Oxford University Press.
Amershi, S. et al. (2019): Guidelines for Human-AI Interaction. CHI Conference on Human Factors in Computing Systems. doi.org/10.1145/3290605.3300233
Microsoft Research: Guidelines for Human-AI Interaction. microsoft.com/research/guidelines-for-human-ai-interaction
Google PAIR (2019, updated 2021): People + AI Guidebook. pair.withgoogle.com/guidebook
IBM: Design for AI. ibm.com/design/ai
IBM: Enterprise Design Thinking for Data and AI. ibm.com/blog/enterprise-design-thinking-for-data-and-ai
ISO 9241-210:2019: Ergonomics of human-system interaction – Part 210: Human-centred design for interactive systems. iso.org/standard/77520
NHS Digital (2022): How a 20-year-old standard is still relevant today. digital.nhs.uk/blog/design-matters

Spec-driven development and AI development tools

GitHub Spec Kit. github.com/github/spec-kit
BMAD Method. github.com/bmad-code-org/BMAD-METHOD
AICAM – AI-Assisted Development Workflow. github.com/cham-space/AICAM
LLM-Coding: Spec-Driven Development – Four Approaches in Detailed Comparison (2026). github.com/LLM-Coding/Spec-Driven
Spec-Driven Development Tools Comparison (2026). github.com/cameronsjo/spec-compare
Best Spec-Driven Development Tools 2026. codemyspec.com/blog/best-spec-driven-development-tools
7 Spec-Driven Development Tools: Spec Kit, Kiro, OpenSpec, Tessl & More (2026). ssojet.com/blog/best-spec-driven-development-tools
Figma: MCP for designers. figma.com/resource-library/mcp-for-designers

Architectures and governance for agent-based processes

OMG: BPMN – Business Process Model and Notation. omg.org/spec/BPMN
OMG: DMN – Decision Model and Notation. omg.org/spec/DMN
Anthropic: Building Effective Agents. anthropic.com/engineering/building-effective-agents
Anthropic: Effective Context Engineering for AI Agents. anthropic.com/engineering/effective-context-engineering-for-ai-agents
LangChain: Human-in-the-Loop Middleware Reference. reference.langchain.com · Human-in-the-Loop Middleware
Anthropic: Demystifying Evals for AI Agents. anthropic.com/engineering/demystifying-evals-for-ai-agents
NIST: AI Risk Management Framework. nist.gov/itl/ai-risk-management-framework