servd

Name: servd
Author: michtio/craftcms-claude-skills

$npx mdskill add michtio/craftcms-claude-skills/servd

Manages Craft CMS deployment, assets, caching, and databases on Servd hosting.

Deploys Craft sites via git push-to-deploy with optional servd.yaml build config.
Depends on servd/craft-asset-storage plugin, S3, svdcdn.com CDN, and SSH tunnels.
Triggers on servd.yaml, plugin handles, environment variables, and specific CLI commands.
Delivers static caching, queue running, backups, and environment variable management.

SKILL.md

.github/skills/servdView on GitHub ↗

---
name: servd
description: "Servd (servd.host) — Craft-specialised managed hosting for Craft CMS. Covers git push-to-deploy with the optional servd.yaml build config, local → staging → production environments with uni-directional Project Config sync, the servd/craft-asset-storage plugin (S3-backed Flysystem volumes on the svdcdn.com CDN, off-server image transforms, Imager-X/ImageOptimize integrations), Servd's static caching (full vs tag-based purge, {% dynamicInclude %}, CSRF injection, cache-busting) and running Blitz alongside it in reverse-proxy mode, MariaDB/MySQL databases over an SSH tunnel, automatic + manual backups, the Dedicated Queue Runner, environment variables and secrets, the ephemeral load-balanced filesystem (Redis + remote volumes for runtime files), plugin/feature constraints, and Servd-vs-Craft-Cloud differences. Triggers on: servd.yaml, servd/craft-asset-storage, servd-asset-storage plugin handle, SERVD_PROJECT_SLUG, SERVD_SECURITY_KEY, SERVD_BUNDLE_HASH, files.svdcdn.com, Servd static caching, {% dynamicInclude %} (Servd), servd-asset-storage/clone, servd-asset-storage/local/pull-database, push-assets, clear-caches/servd-static-cache, clear-caches/servd-edge-caches, Dedicated Queue Runner, Servd Asset Platform, deploy to Servd, host Craft on Servd, Servd vs Craft Cloud. Do NOT trigger for Craft Cloud (use the craft-cloud skill), generic Craft deployment on Forge/bare metal (craftcms/deployment.md), or general DDEV local dev unrelated to Servd parity (ddev)."
---

# Servd — Managed Hosting for Craft CMS

Reference for Servd (servd.host), a Craft-specialised managed hosting platform. Covers git push-to-deploy and the `servd.yaml` build config, the local → staging → production workflow, the `servd/craft-asset-storage` plugin, Servd's static caching (and running Blitz alongside it), databases over SSH, backups, the queue runner, the ephemeral filesystem, and how Servd differs from Craft Cloud.

This skill is scoped to **Servd specifically** — what's different on Servd vs running Craft yourself on Forge or bare metal, and vs Pixel & Tonic's Craft Cloud. For generic Craft deployment, see the `craftcms` skill's `deployment.md`. For Craft Cloud, see the `craft-cloud` skill.

## Companion Skills — Load When Needed

- **`craftcms`** — When the Servd topic intersects plugin or module PHP (ephemeral-filesystem guards, queue-job design, asset filesystem code).
- **`craft-site`** — When Servd intersects front-end templating (`{% dynamicInclude %}` islands in cached pages, transform usage, CSRF in cached forms).
- **`ddev`** — For local development; Servd has no first-party local environment, so DDEV is the standard local stack.
- **`craft-php-guidelines`** — When editing plugin PHP to add ephemeral-filesystem checks.

## Documentation

Authoritative sources used to write this skill (Servd's own docs):

- Docs landing: https://servd.host/docs
- The Servd workflow: https://servd.host/docs/the-servd-workflow
- Node build step (servd.yaml): https://servd.host/docs/node-build-step
- Asset volumes & filesystems: https://servd.host/docs/servd-asset-volumes-and-filesystems
- Installing the plugin: https://servd.host/docs/installing-the-servd-plugin
- Static caching: https://servd.host/docs/static-caching
- Caching with Blitz: https://servd.host/docs/caching-with-blitz
- Handling runtime-created files: https://servd.host/docs/handling-runtime-created-files
- Dedicated queue runner: https://servd.host/docs/dedicated-queue-runner
- Backup & restore: https://servd.host/docs/backup-restore
- Plugin console commands: https://servd.host/docs/servd-plugin-console-commands
- Plugin source: https://github.com/servdhost/craft-asset-storage

Per-claim URLs appear in each reference file. Last verified against the docs on 2026-05-30. Some operational details (cron, exact plan tiers) are not in the public docs and are flagged as **Verify** where they appear.

## What's Different on Servd vs Self-Hosted

Each row is a place self-hosted habits will mislead you.

| Concern | Self-hosted | Servd |
|---|---|---|
| Config file | `.env`, `config/*.php`, web-server config | **`servd.yaml`** at repo root for the build step (optional; overrides dashboard); platform settings + runtime env vars in the Servd dashboard |
| Deploy | Whatever you've wired | **Git push-to-deploy** (GitHub/GitLab/Bitbucket or any SSH host) → Composer install + optional Node build |
| Environments | Yours to define | Fixed **local → staging → production**, **uni-directional**; `allowAdminChanges` off everywhere except local |
| Filesystem | Local disk | **Ephemeral + load-balanced** — disk writes don't persist; use Redis (Craft data cache) or a remote asset volume |
| Assets | Local or your own S3 config | **`servd/craft-asset-storage`** — S3-backed Flysystem on the `*.files.svdcdn.com` CDN, auto-separated per environment |
| Image transforms | Native / Imager-X / ImageOptimize on-server | **Off-server** transforms via the Servd Asset Platform; Imager-X uses `transformer: 'servd'` |
| Database | Whatever you installed | **MariaDB or MySQL 8**, reached over an **SSH tunnel** |
| Page caching | Blitz or similar | **Servd static caching** built in; Blitz runs **alongside** it in reverse-proxy mode (not instead of) |
| Queue | You run a worker | Default AJAX-triggered; opt into the **Dedicated Queue Runner** (paid plans) for isolated immediate processing |
| Cron | `crontab` | **Not documented** as a user-configurable feature — design around the queue (**Verify** for a given plan) |
| Redis | You install it | **Provided** — Craft's data cache is auto-mapped to a stateful Redis |
| SSH | `ssh user@server` | **Yes** — SSH sessions (used e.g. for the DB tunnel) |
| Env vars | `.env` | Dashboard-managed per environment (not a committed `.env`) |

### Servd vs Craft Cloud (quick contrast)

Both are managed Craft hosting with git deploy, ephemeral filesystems, S3 assets, off-server transforms, and dashboard env vars. Key differences for a developer:

| | Servd | Craft Cloud |
|---|---|---|
| Repo config | `servd.yaml` (build) + dashboard | `craft-cloud.yaml` |
| Asset layer | `servd/craft-asset-storage` plugin | `craftcms/cloud` bundled filesystem |
| Database | MariaDB **or** MySQL 8 | MySQL 8 / Postgres 15 (**no MariaDB**) |
| SSH | Yes | No |
| First-party CLI | None (plugin console commands + dashboard) | `craftcms/cloud` + `php craft cloud/up` |
| Caching | Servd static cache; **Blitz runs alongside** | Edge static caching; **Blitz redundant** |
| Transforms | Servd Asset Platform (`svdcdn.com`) | Cloudflare Images at the edge |
| Queue | Dedicated Queue Runner (paid) | Auto-processed |

## Common Pitfalls (Cross-Cutting)

- **Writing to disk and expecting persistence.** The filesystem is ephemeral and load-balanced — writes vanish and aren't shared across instances. Use Craft's data cache (auto-mapped to Redis) or a remote asset volume. See `references/limitations.md`.
- **Making schema/Project Config changes anywhere but local.** Servd sets `allowAdminChanges: false` on staging and production and syncs uni-directionally (local → staging → production). Make changes in local, commit, deploy. See `references/deploy-and-environments.md`.
- **Treating Blitz as a replacement for Servd's caching.** On Servd you run Blitz *alongside* the static cache in **reverse-proxy mode** (Yii Cache Storage + HTTP Generator + Servd Static Cache Purger) — Blitz's own server-rewrite mode is broken by Servd's load balancing. See `references/caching.md`.
- **Committing a `.env` for runtime config.** Runtime env vars live in the Servd dashboard per environment, not a committed `.env`. `SERVD_PROJECT_SLUG` / `SERVD_SECURITY_KEY` come from the dashboard's Assets page.
- **Using a local asset volume.** User assets must use the `servd/craft-asset-storage` filesystem so they land on the Servd Asset Platform and survive deploys. See `references/asset-storage.md`.
- **Putting `composer install` / `npm run build` in a CI action.** Servd runs both during its build step. Configure the Node build via `servd.yaml` or the dashboard instead. See `references/deploy-and-environments.md`.
- **Assuming arbitrary cron.** Servd doesn't document user-configurable cron. Move recurring work into queue jobs and the Dedicated Queue Runner. **Verify** per plan. See `references/database-and-queue.md`.
- **Choosing the wrong database habits.** Servd supports MariaDB and MySQL 8; reach the DB over the SSH tunnel, not a direct public port. See `references/database-and-queue.md`.

## Reference Files

Read the relevant reference file(s) for your task. Multiple files often apply.

**Task examples:**

- "Deploy a Craft site to Servd" → `deploy-and-environments.md`
- "Configure the Node build step / `servd.yaml`" → `deploy-and-environments.md`
- "Set up environments and sync between them" → `deploy-and-environments.md` + `local-dev.md`
- "Install Servd asset storage" → `asset-storage.md`
- "Why are my uploaded assets disappearing?" → `asset-storage.md` + `limitations.md`
- "Set up image transforms on Servd" → `asset-storage.md`
- "Enable static caching" → `caching.md`
- "Run Blitz on Servd" → `caching.md` (Blitz reverse-proxy mode)
- "Add a dynamic island to a cached page" → `caching.md` (`{% dynamicInclude %}`)
- "Connect to the Servd database" → `database-and-queue.md`
- "Set up the queue / run recurring jobs" → `database-and-queue.md`
- "Back up / restore / sync the database" → `database-and-queue.md` + `local-dev.md`
- "Set up local development for a Servd project" → `local-dev.md`
- "Pull production assets/database to local" → `local-dev.md`
- "Why does my plugin's file write fail on Servd?" → `limitations.md`
- "What plugins work on Servd?" → `limitations.md`
- "Should I use Servd or Craft Cloud?" → `limitations.md` (Servd vs Cloud) + this file's table

Load only the reference files your task needs.

| Reference | Scope | ~Lines |
|---|---|---:|
| `references/deploy-and-environments.md` | Git push-to-deploy, the build step (Composer + Node, `servd.yaml` keys, Node versions), environments (local → staging → production, uni-directional), Project Config + `allowAdminChanges`, env vars & secrets, the deploy/clone workflow | ~150 |
| `references/asset-storage.md` | `servd/craft-asset-storage` plugin (composer package, handle, install), `SERVD_PROJECT_SLUG`/`SERVD_SECURITY_KEY`, the Servd filesystem on `*.files.svdcdn.com`, per-environment dirs, off-server transforms, Imager-X (`transformer: 'servd'`) and ImageOptimize integrations | ~140 |
| `references/caching.md` | Servd static caching (enable + TTL, Full vs Tag-Based purge, exclude prefixes, `{% dynamicInclude %}` tag, CSRF injection, auto cache-busting on save, `clear-caches/servd-static-cache` + `servd-edge-caches`), and running Blitz in reverse-proxy mode | ~140 |
| `references/database-and-queue.md` | MariaDB / MySQL 8, SSH-tunnel access, automatic + manual backups (30-day retention, 90-day deleted-asset window), the Dedicated Queue Runner, the cron caveat, console sync commands | ~130 |
| `references/local-dev.md` | DDEV-based local dev (no first-party Servd local env), `SERVD_*` vars for local, `servd-asset-storage/local/pull-assets`·`push-assets`·`pull-database`·`push-database`, `servd-asset-storage/clone`, uni-directional sync discipline | ~120 |
| `references/limitations.md` | Ephemeral + load-balanced filesystem (Redis + remote volumes for runtime files), plugin/feature constraints, the documented-vs-unknown gaps (cron), the full Servd-vs-Craft-Cloud comparison, and the repo **detection signals** (`servd/craft-asset-storage`, `servd.yaml`, `SERVD_*` env vars) | ~140 |

More from michtio/craftcms-claude-skills

Skill	Description
craft-cloud	Craft Cloud — Pixel & Tonic's serverless hosting platform for Craft CMS. Covers craft-cloud.yaml configuration, the Build → Migrate → Release deploy pipeline, the craftcms/cloud extension package, edge image transforms via Cloudflare, edge static caching with cache.rules + ESI, Cloud-managed S3 filesystem, MySQL 8 / Postgres 15 databases (no MariaDB, no tablePrefix), Console-based command runner and scheduled cron (once-per-hour minimum), auto-handled queue jobs, custom domains and SSL, preview environments per branch, Cloud limitations (ephemeral filesystem, no SSH, no .htaccess, no built-in mail), plugin development requirements for Cloud compatibility, and self-hosted → Cloud migration. Triggers on: craft-cloud.yaml, craftcms/cloud package, cloud.esi(), php craft cloud/up, php craft cloud/setup, App::isEphemeral(), CRAFT_EPHEMERAL, edge.craft.cloud, preview.craft.cloud, CRAFT_CLOUD_PROJECT_ID, CRAFT_CLOUD_ENVIRONMENT_ID, CRAFT_CLOUD_CDN_BASE_URL, Build → Migrate → Release, Cloud filesystem, Cloud-compatible plugin, Cloudflare Images at edge, AssetsFs, static-caching rules, ESI islands, deploy to Craft Cloud, migrate to Craft Cloud, self-hosted to Cloud, Craft Cloud quotas, Craft Cloud regions. Do NOT trigger for Servd (use the servd skill) or generic Craft deployment on Forge/bare metal (craftcms/deployment.md). Do NOT trigger for general DDEV local dev unrelated to Cloud parity.
craft-content-modeling	Craft CMS 5 content modeling — sections, entry types, fields, Matrix, relations, project config, and content architecture strategy. Covers choosing section types, designing entry types and field layouts, selecting field types, configuring Matrix and nested entries, relations and eager loading, and multi-site propagation. Triggers on: section types (single, channel, structure), entry types, field types, field layout design, field type selection, Matrix, nested entries, relatedTo, eager loading, .with()/.eagerly(), categories, tags, globals, global sets, preloadSingles, propagation, multi-site content, project config, YAML, content strategy, taxonomy, asset volumes, filesystems, image transforms, user groups, content permissions, entrify/entrification, CKEditor vs Matrix, CMS editions, multi-language, language groups, localization, translation method, field translation, content migration, field instances, Formie forms as elements vs project config, cross-environment Formie deployment, multi-site Formie translation, element index sources, elementSources, Entries index sidebar, tableAttributes, defaultSort, authoring schema from code (service layer vs project.yaml + pc/apply). Always use when planning content architecture, creating sections/fields, configuring Matrix, setting up relations, choosing field types, designing field layouts, planning multi-site propagation, or tidying the Entries element index. Do NOT trigger for PHP plugin/module development, custom field type code, front-end Twig, or buildchain.
craft-garnish	Garnish — Craft CMS's built-in JavaScript UI toolkit for the control panel. Covers the class system (Garnish.Base.extend, init, setSettings, addListener, on/off/trigger, destroy), UI widgets (Modal, HUD, DisclosureMenu, MenuBtn, CustomSelect, ContextMenu, Select), drag system (BaseDrag, DragSort, DragDrop, DragMove), form widgets (NiceText, CheckboxSelect, MixedInput, MultiFunctionBtn), utilities (key constants, ARIA helpers, focus management), and Craft integration (GarnishAsset, webpack externals, Craft.* pattern). Triggers on: Garnish.Base.extend, Garnish.Modal/HUD/DragSort/DisclosureMenu, ESC_KEY/RETURN_KEY, activate/textchange events, UiLayerManager, registerShortcut, trapFocusWithin/releaseFocusWithin/setFocusWithin, garnishjs, GarnishAsset, CpAsset, CP JavaScript, modal/HUD popover, Craft.CP, Craft.Slideout, Craft.ElementEditor, onSortChange/onOptionSelect/onSelectionChange, aria-modal, focus trap, keyboard navigation CP, this.base(), window.Garnish, CP memory leak, event listener cleanup, jQuery .on() in CP, custom slideout/overlay lifecycle, disable kills listeners, aria-hidden retained focus, inert attribute. Always use when writing, editing, or reviewing JavaScript that runs in the Craft CP — plugin CP assets, custom field type JS, element index JS, CP webpack config, or code importing garnishjs / referencing window.Garnish. Also for CP accessibility, keyboard interactions, drag-sort, or CP JS memory issues. Do NOT trigger for front-end JavaScript (Alpine, Vue, htmx) or Twig templates (craft-site).
craft-php-guidelines	Craft CMS 5 PHP coding standards and conventions. ALWAYS load when writing, editing, reviewing, or discussing any PHP in a Craft plugin or module — even small edits. Also when running ECS, PHPStan, or scaffolding with ddev craft make. Covers: PHPDoc blocks (@author, @since, @throws chains), section headers (=========), class organization, naming conventions (services, queue jobs, records, events, enums), defineRules() and validation, beforePrepare() and addSelect(), MemoizableArray, DateTimeHelper vs Carbon, strict_types/declare(strict_types=1), short nullable notation (?string), typed properties, void returns, control flow (early returns, match over switch), CP Twig template conventions, form macros, translations (Craft::t), ECS/PHPStan config, scaffolding commands, and the verification checklist. Triggers on: writing service classes, models, controllers, elements, element queries, records, queue jobs, migrations, or any PHP class in a Craft context; PHP code review, refactoring, or style questions; requireAdmin vs requirePermission, manageSettings, settings permission, allowAdminChanges, read-only settings, getCpNavItem dead nav item, permission handle constant on owning controller, no-em-dash user-facing copy. NOT for front-end Twig (craft-twig-guidelines), template architecture (craft-site), or CP JavaScript/Garnish (craft-garnish). If you are touching PHP in a Craft context, you need this skill.
craft-plugins	Index and router for plugin-specific Craft CMS 5 guidance — configuration, Twig API, PHP/programmatic API, migrations, deployment, and pitfalls for the third-party plugins this pack documents. A plugin task routes here at any altitude: front-end (Twig/styling), back-end (PHP, content migrations, events), content modeling, or deployment. Triggers whenever a task names one of these plugins in ANY context (build, configure, style, render, query, import, migrate, deploy, translate, cache, debug): Formie (forms, submissions, File Upload field, form in a migration, notifications, translation overrides), SEOmatic (meta, sitemaps, JSON-LD, SEO field), Blitz (static/page caching, purge), Feed Me (XML/JSON/CSV import), Imager-X (transforms, srcset), ImageOptimize (OptimizedImages, responsive images), CKEditor (rich text, nested entries), Sprig (reactive, htmx), Element API (JSON endpoints), Retour (redirects, 404s), Navigation (nav menus), Hyper (link field), Colour Swatches, Password Policy (HIBP), Typogrify, Cache Igniter, Knock Knock (staging password), Elements Panel (N+1 debug), Sherlock (security scan), Amazon SES (SES/SNS bounce), Embedded Assets (oEmbed), Timeloop (recurring dates), Vite (craft.vite.*, asset bundling). Always load when a task names one of these plugins, even for PHP/migration/deployment — read references/<plugin>.md first. Do NOT trigger for Craft core with no plugin named (craftcms), general template architecture (craft-site), or general content modeling (craft-content-modeling).
craft-project-setup	Scaffold Claude Code configuration specifically for Craft CMS projects. Generates CLAUDE.md and .claude/rules/ files tailored to the project type (plugin, site, module, hybrid, or monorepo). Only for Craft CMS projects — not for Next.js, Laravel, or other frameworks. Triggers on: 'set up Claude for this Craft project', 'initialize CLAUDE.md', 'scaffold project config', 'configure Claude Code for Craft', 'create CLAUDE.md', 'missing CLAUDE.md', 'does this project have a CLAUDE.md', 'bootstrap Claude config', 'new Craft project setup', 'onboard a developer to this Craft project', 'generate .claude/rules', 'set up coding standards config', 'upgrade Claude config', 'update CLAUDE.md', 'compare my setup', 'is my config up to date', 'audit my Claude setup', 'redo project setup'. Also triggers when starting work in a new Craft CMS project that lacks a CLAUDE.md file, or when the user wants to check or upgrade an existing configuration. Detects project type from composer.json (craft-plugin, craft-module, project), .ddev/config.yaml, templates/, config/project/, and modules/. NOT for installing Craft CMS itself, creating DDEV environments, writing PHP code, building templates, or content modeling. NOT for non-Craft projects — if the project is React, Next.js, Laravel, or any non-Craft framework, this skill does not apply.
craft-site	Craft CMS 5 front-end Twig development — atomic design, template architecture, components, Vite buildchain. Covers atoms/molecules/organisms, props/extends/block patterns, layout chains, view routing, content builders, image presets, Tailwind named-key collections, multi-brand CSS tokens, JavaScript boundaries (Alpine/DataStar/Vue, tabs, accordions), Vite asset loading, and front-end auth (login, registration, password reset, profiles). Triggers on: {% include ... only %}, {% embed %}, _atoms/_molecules/_organisms/_views/_builders, component--variant.twig, _component--props.twig, collect({}), utilities prop, data-brand theming, hero/card components, Matrix block rendering, craft.vite.script, vite.php, vite.config.ts, buildchain, per-page scripts, Blitz static/page caching, ImageOptimize, Imager-X, responsive images, srcset, image transforms, SEOmatic meta/OpenGraph/JSON-LD, Sprig, htmx, multi-language, hreflang, localization, Formie form styling, login/registration form, RSS/Atom/JSON feeds, XML sitemap, search page, .search(), headless GraphQL, Next.js/Nuxt/Astro integration, example-templates command, render builder, fluent BaseTag {{ tag.render() }}, progressive enhancement. Always use when creating, editing, or reviewing Craft front-end Twig templates, components, layouts, views, builders, buildchain, or front-end auth — including plugin template integration (Blitz, SEOmatic, Sprig, Formie, Imager-X). Do NOT trigger for PHP plugin/module development (craftcms) or content modeling (craft-content-modeling).
craft-twig-guidelines	Twig coding standards and conventions for Craft CMS 5 templates. ALWAYS load this skill when writing, editing, or reviewing any .twig file in a Craft CMS project — even for small edits. Covers: variable naming (camelCase, no abbreviations), null handling (?? operator, ??? with empty-coalesce plugin), whitespace control ({%- trimming, NOT {%- minify -%}), include isolation (always use 'only'), Craft Twig helpers ({% tag %}, tag(), attr(), \|attr filter, \|parseAttr, \|append, svg()), collect() for props and class collections, .implode(), comment headers with ========= separators on component files, and common pitfalls (snake_case, macros as components, hardcoded colors). Triggers on: Twig template creation, editing, or review; .twig files; {% include %} with 'only'; {% tag %} and polymorphic elements; collect() and props.get(); class string building; attr() and \|attr filter; svg() with styling and aria; ?? and ??? null coalescing; whitespace control and blank lines in output; minify alternatives; Twig file headers and comment blocks; variable naming conventions in Twig; currentSite, siteUrl, craft.entries, .eagerly(), .collect in template context; \|e('js') aggressive escaping (spaces become \uXXXX), js escaper, grepping escaped translated strings. NOT for Twig architecture patterns, atomic design structure, or template routing (use craft-site). NOT for PHP code (use craft-php-guidelines). NOT for content modeling or field configuration (use craft-content-modeling).
craftcms	Craft CMS 5 plugin and module development — extending Craft with PHP. Covers elements, element queries, services, models, records, controllers, migrations, queue jobs, console commands, field types, native fields, events, behaviors, Twig extensions, widgets, filesystems, permissions, project config, GraphQL, testing, and debugging. Triggers on: beforePrepare()/afterSave()/defineSources()/defineTableAttributes()/attributeHtml(), MemoizableArray, BaseNativeField, EVENT_REGISTER_/DEFINE_/BEFORE_/AFTER_, CraftVariable, custom element or field type (normalizeValue/serializeValue/inputHtml), webhook, API endpoint, queue/batch job, CP section, dashboard widget, utility page, element action/exporter/condition, registerUserPermissions, requirePermission vs requireAdmin, manageSettings, allowAdminChanges, canView/canSave/canDelete, defineRules, elevated session, project-config/apply, drafts/revisions, element edit sidebar (EVENT_DEFINE_SIDEBAR_HTML) + toolbar buttons, metaFieldsHtml, VueAdminTable, GeneralConfig. Always use when writing, editing, or reviewing Craft plugin/module PHP — even when no API is named. For plugin-specific work also load craft-plugins. Do NOT trigger for front-end Twig (craft-site) or content modeling (craft-content-modeling).
ddev	DDEV local development environment for Craft CMS projects. ALWAYS load this skill when running any ddev command, configuring .ddev/config.yaml, or troubleshooting local container issues. Covers: config.yaml settings (project type, PHP/Node versions, database, docroot), shorthand commands (ddev composer, ddev craft, ddev npm), add-ons (ddev add-on get for Redis; built-in Mailpit), custom commands (.ddev/commands/), Vite dev server exposure (web_extra_exposed_ports, web_extra_daemons), database import/export (ddev import-db, ddev export-db, ddev craft db/backup), Xdebug toggling (ddev xdebug on/off), sharing local sites (ddev share, temporary public URLs), and troubleshooting (ddev poweroff, ddev logs, ddev describe, ddev delete, port conflicts, container restart issues). Triggers on: ddev start/stop/restart, ddev craft, ddev composer, ddev npm, ddev ssh, ddev import-db, ddev export-db, ddev xdebug, ddev share, ddev add-on, ddev poweroff, ddev describe, ddev logs, .ddev/config.yaml, web_extra_exposed_ports, web_extra_daemons, PHP version or Node version in local dev, database backup/restore locally, ran npm/composer on host instead of ddev, wrong node_modules architecture, local dev environment for Craft CMS, ddev-injected PRIMARY_SITE_URL, .ddev/.env.web regenerated on restart, CRAFT_ env var overriding config/general.php, general-config edit has no effect. NOT for production deployment, CI/CD pipelines, GitHub Actions, or server configuration. NOT for Docker/container usage outside of DDEV.