Frequently Asked
Questions

Dalia is a structured development environment that amplifies your ability to build production-quality Drupal code. You describe what you need, refine the specification through a guided conversation, review and shape the implementation plan, then oversee code generation with Drupal-specific knowledge injected at every step.

Think of it as a power tool for Drupal developers: you stay in control of every critical decision while the tedious parts — boilerplate, API lookups, pattern matching — happen at machine speed.

Three things:

• A DDEV environment for your Drupal project
• A Claude Code subscription (Max or Team plan with Claude Code access)
• A Drupal 10.3+ project

Dalia is distributed as a DDEV add-on. One command installs it into your existing development environment.

No. Dalia runs entirely on your existing Claude Code subscription. There are no API keys to manage, no per-token billing, and no surprise charges. Predictable cost, always.

The core Dalia application is closed-source, free to use, and currently in closed beta. However, two key components that power Dalia are fully open source:

• AI Task Manager — orchestrates specification, planning, task breakdown, and execution
• Self-Review — powers the inline commenting UIs for plan review and code review

Both are available on GitHub.

You describe what you want to build, and the AI interviews you to fill in the gaps. It asks clarifying questions, reveals hidden requirements based on your existing codebase, and suggests improvements. The result is a refined specification that's far more precise than your original prompt.

Voice input is encouraged here — dictated prompts tend to include more context and produce better specifications than typed ones.

Before any code is written, Dalia presents a detailed implementation plan. You review it with inline comments — categorized as bug, security, style, question, task, or nit — just like a code review. A separate validation document locks acceptance criteria before execution begins.

This is one of two crucial moments in the pipeline. Catching architectural issues here is far cheaper than catching them after code is generated.

The approved plan is broken into atomic tasks, each categorized by the Drupal skill necessary to build it — entities, forms, plugins, theming, and so on. This semantic categorization selects the most appropriate agent for each task and orchestrates sequential and parallel execution.

RAG stands for Retrieval-Augmented Generation. LLM training data for Drupal is a garble of versions — Drupal 7 patterns, deprecated APIs, mixed conventions. Without deliberate intervention, AI-generated Drupal code lacks the specificity that professional work demands.

Dalia's RAG system injects semantically relevant, current Drupal documentation at runtime. This anchors every generation to correct best practices rather than outdated or incorrect patterns from the model's training data.

Yes. While a generation is running, you can stop the agent, send one or more steering messages to provide guidance or course-correct, then resume. Your messages are delivered together when the next session starts.

When the agent explicitly requests input (awaiting-input status), your message automatically triggers a resume — no manual stop/resume needed.

All code edits are presented in a diff view, similar to a GitHub pull request but entirely private and local. You review each file with inline comments categorized as bug, security, style, question, task, or nit.

When you submit your review, a separate AI agent applies your feedback. You can then review the updated changes again. Nothing goes public until you endorse it.

The AI Task Manager is an open-source component that drives most of Dalia's pipeline. It runs the specification interview, generates the implementation plan, decomposes the plan into atomic tasks categorized by Drupal skill, and orchestrates their execution order — deciding which tasks can run in parallel and which must run sequentially.

It's a standalone project that Dalia integrates. You can find it on GitHub.

A local Git branch with commits containing all the generated code. From there, you treat it exactly as if you had written it yourself — push it, open a PR, rebase it, cherry-pick parts of it, or keep iterating locally. Dalia doesn't lock you into any workflow. It's just code on a branch.

Dalia can automatically validate generated code against your requirements using two approaches:

• Browser validation — Playwright scripts test the UI in a real browser
• CLI validation — Drush commands and PHPUnit tests verify backend behavior

When validation fails, Dalia enters a fix-and-retry loop. Self-validation is optional — you can enable it when creating a generation or trigger it manually from the review screen.

Yes. You create context items — markdown files with YAML frontmatter — in your project's .dalia/context/ directory. These are embedded using the same RAG system and injected into agent prompts alongside Drupal documentation.

Use context items to describe your project's architecture, coding conventions, module relationships, or anything the AI should know when generating code for your specific project.

Yes. You can attach JPEG, PNG, GIF, and WebP images (up to 5 MB each) via drag-and-drop, clipboard paste, or file picker. Images work in the spec chat, steering messages, and the new generation form.

This is useful for sharing mockups, screenshots of existing UI, error messages, or any visual reference that helps the AI understand your requirements.

Dalia uses Claude models, configurable per phase. The available models are Opus, Sonnet, and Haiku. Recommended configuration:

• Spec & Planning — Opus (strongest reasoning for specification refinement and plan creation)
• Tasking, Coding & Validation — Sonnet (balanced reasoning for task breakdown, code generation, and validation)

You can change models at any time from the Settings page. Changes take effect for the next phase, not mid-phase.

Yes. Dalia runs inside your DDEV environment. All generated code, plans, tasks, and review artifacts stay on your machine. Nothing is pushed to any remote repository until you explicitly do so. The code review step is private and local — no noise for your peers, no code you haven't endorsed.