Building Drupal Recipes with an AI Co-Developer

How Gluebox.com LLC uses Claude Code to build the RSVP System

What Is the RSVP System?

The RSVP System is an open-source calendar and event platform built on Drupal 11. It's designed as a set of composable Drupal Recipes — reusable configuration packages that can be applied to any Drupal site to stand up event management, community directories, mapping, search, and more.

Rather than shipping a monolithic installation profile, we break everything into small, focused ingredients (a single field, a taxonomy vocabulary, a content type) that compose into larger recipes (a full-stack event platform, a project board, a marketing toolkit). This means you can adopt exactly the pieces you need.

We're building this in the open. Our project website, rsvp-system.org, runs a live copy of the RSVP System. It's not a demo — it's the real thing, developed in real-time. As we add features, package new recipes, and refine the platform, those changes ship directly to the live site. If you visit today, you're seeing the current state of the project, not a polished snapshot from months ago.

The project is maintained by Gluebox.com LLC and spans several repositories:

Why a Separate Requirements Package?

Drupal Recipes handle configuration, not code. They can enable modules, but they can't download them. That's Composer's job.

This creates a chicken-and-egg problem: you need the modules installed before a recipe can configure them. Our solution is to split the concern cleanly:

1. composer require rsvp-system/rsvp-requirements pulls in all 30+ contrib modules (Smart Date, ECA, Search API, Leaflet, Feeds, and more).
2. drush recipe recipes/rsvp_full_stack configures those modules into a working event system.

Code and configuration stay decoupled. You can update modules independently of recipes, and recipes remain portable across different Drupal projects.

The Development Workflow

Here's where things get interesting. We develop the RSVP System on a local DDEV site and use Claude Code — Anthropic's AI-powered CLI tool — as a co-developer throughout the process.

How We Build a Recipe

Our workflow follows a loop:

┌─────────────────────────────────────────────────┐
│                                                   │
│   1. Configure on DDEV site                       │
│      (content types, fields, views, etc.)         │
│                                                   │
│   2. Export configuration                         │
│      (drush config:export → YAML files)           │
│                                                   │
│   3. Package into recipe ingredients              │
│      (organize YAML + write recipe.yml manifests) │
│                                                   │
│   4. Publish to Packagist                         │
│      (so recipes install via Composer)             │
│                                                   │
│   5. Apply recipes to a clean site                │
│      (verify everything works end-to-end)         │
│                                                   │
│   6. Iterate                                      │
│      (back to step 1)                             │
│                                                   │
└─────────────────────────────────────────────────┘

The DDEV site is our sandbox. The recipes are the distributable output. The recipes themselves are installed back into the DDEV site via Composer, so the whole system stays circular and self-testing.

Where Claude Code Fits In

Claude Code is an AI assistant that runs directly in the terminal. It can read files, search codebases, edit code, and run commands — all within a conversational interface. We use it as a hands-on collaborator at every stage of the workflow:

Understanding configuration exports. After exporting config from Drupal, we often have dozens of interrelated YAML files. Claude Code can scan the export directory, identify which files belong to a specific feature (say, a new content type and its fields), and map out the dependencies between them.

Packaging ingredients. Claude Code helps us write recipe.yml manifests — the files that tell Drupal what config to import, which modules to enable, and which other recipes are prerequisites. It reads the raw config YAML, understands the Drupal entity relationships, and produces correctly structured recipe definitions.

Keeping recipes in sync. When we change configuration on the DDEV site, Claude Code can diff the updated config export against what's already packaged in our recipes and identify what needs to be updated.

Maintaining the requirements metapackage. When a new recipe needs a module that isn't in our composer.json yet, Claude Code flags it and helps us add the dependency with the right version constraint.

Cross-repository awareness. Because Claude Code can read across all our project directories simultaneously, it understands how a field storage definition in rsvp-recipes/ingredients/fields/ relates to a content type in ingredients/content_types/, which depends on a module declared in rsvp-system-requirements/composer.json, which is installed in rsvp-system-core/web/modules/contrib/. That cross-cutting awareness is hard to maintain manually.

What This Looks Like in Practice

A typical session might go like this:

Developer: "I just added a new 'community_event' content type on the DDEV site with smart date fields, a geofield, and a reference to the community taxonomy. Can you help me package this as a recipe?"

Claude Code: Reads the config export directory, identifies the 12 relevant YAML files (node type, field storages, field instances, form display, view display), checks which field storages already exist as ingredients, drafts a new ingredients/content_types/community_event/recipe.yml that depends on the existing field and taxonomy ingredients, and flags that drupal/smart_date is already in the requirements metapackage.

The AI doesn't replace the developer's judgment about what to build. It accelerates the mechanical work of how to package it — reading config files, understanding dependencies, writing boilerplate YAML, and catching things you'd otherwise miss.

Project Architecture at a Glance

rsvp-recipes/
├── recipes/
│   ├── rsvp_full_stack/       ← Main recipe: installs everything
│   ├── rsvp_core_data/        ← Just content types and taxonomies
│   ├── rsvp_project_board/    ← Kanban-style project management
│   └── rsvp_marketing/        ← Marketing and outreach tools
└── ingredients/
    ├── content_types/          ← 5 content type recipes
    ├── fields/                 ← 15 field storage recipes
    ├── feeds/                  ← 3 data import recipes
    ├── taxonomy/               ← 6 vocabulary recipes
    ├── profile/                ← 6 user profile field recipes
    ├── system/                 ← Base config and prerequisites
    ├── formatting/             ← Date/display formatting
    ├── logic/                  ← ECA automation rules
    └── ui/                     ← Menus, sections, boards

Each ingredient is a self-contained recipe that handles exactly one concern. The top-level recipes compose them together. This granularity means you can adopt the full stack or cherry-pick individual pieces.

Getting Started

If you want to try the RSVP System yourself:

# Start with a Drupal 11 project, then:
composer require rsvp-system/rsvp-requirements
composer require rsvp-system/rsvp-recipes

# Apply the full stack
drush recipe recipes/contrib/rsvp-recipes/recipes/rsvp_full_stack

# Or just the core data structures
drush recipe recipes/contrib/rsvp-recipes/recipes/rsvp_core_data

Learn More

• RSVP System (live site): rsvp-system.org
• Maintained by: Gluebox.com LLC
• Claude Code: claude.ai/claude-code

This project is open source under the GPL-2.0-or-later license. Contributions and feedback are welcome.