Four Kitchens × AI: where one person does more.
A research-grounded read of the Four Kitchens engineering ecosystem and where AI is the multiplier it already wants to be. Built outward from drupal-ai-standards — the AI work you've already shipped — and triangulated against the 2026 Drupal AI landscape. The spine is eighteen concrete builds, grouped by area of savings: engineering practice, project bootstrap, sprint operations, editorial workflow, and delivery & maintenance.
What this is, and how it was built.
This report is Newfangled's outside-in read of Four Kitchens' engineering ecosystem in May 2026 — what we can see in your public repositories, your team page, your conference talks, and the work you've made open-source. It is a recommendation, not an audit: every observation below is grounded in something we read, but everything we couldn't verify is flagged in the open-questions section near the end.
The spine is opportunity, not threat. AI in 2026 is no longer a productivity tool layered on top of existing work — for a Drupal shop with deep multisite expertise, it changes which person does which piece of work. The body of the report identifies eighteen of those role-compression moments, grouped by who's empowered.
-
Research-grounded
Every claim about Four Kitchens cites a public source — repo, commit, talk, team page. We don't speculate about what you do internally.
-
Opportunity-framed
Each opportunity is framed as "this AI capability lets one person do work that used to require more" — not as "adopt X tool."
-
Honest about gaps
A dedicated section lists what we couldn't determine from outside. Many recommendations soften or sharpen depending on what's true internally.
drupal-ai-standards is already the seed of your AI strategy.
In late April 2026 — barely a month before this report — the initial commit of drupal-ai-standards landed on GitHub: a Composer plugin from day one, with a project-level AGENTS.md scaffold, a three-layer ownership model (shared / project / personal), six initial skills for Drupal-specific tasks, a SECURITY.md with non-negotiables, and an always-on instruction file that codifies WCAG 2.2 AA across 49 specific anti-patterns. We can't see your internal usage. But the architecture decisions in that repo — made very deliberately, very recently — tell us most of what we need to know about how Four Kitchens is now thinking about AI in development work.
A shared layer of judgment for any IDE-agnostic AI agent on a Drupal project.
A six-phase setup prompt scaffolds an AGENTS.md per project. Six skills ship in the initial release, covering git commit conventions, draft PR descriptions, security-update reviews, documentation creation and updates, and a Drupal bundle-classes pattern. The always-on a11y instruction is loaded into every session — not because AI is unsafe by default, but because Four Kitchens has codified what "WCAG 2.2 AA" means in practice, and now any agent gets that judgment for free.
The three-layer model (shared standards / project overrides / personal preferences) means individual developers can tune without breaking the team default. It's the right shape.
The hard problem with AI in agency work isn't capability — it's consistency.
An AI agent that drafts Drupal code that works on the developer's machine but fails accessibility checks, picks the wrong module pattern, or violates a client's content model — that's a net negative. drupal-ai-standards exists because Four Kitchens already understood this: it's not enough to give a developer access to an LLM; you have to give the LLM access to Four Kitchens' standards.
This is rare. Most agencies layered AI on top of practice in 2024–25. You codified practice for AI. Everything in this report builds on that move.
What we don't yet see in public: the operational depth around the seed. There is no AGENTS.md scaffold from this plugin checked into any client repository we can read. No FIRE command for invoking the standards from inside CI. No documented adoption metric or before/after measure of AI-assisted output quality. Those are not concerns — they are the work that converts an excellent foundation into a daily-use system, and they shape much of what follows in this report.
The Drupal AI landscape, mid-2026.
The decisions in drupal-ai-standards weren't made in a vacuum. The Drupal AI ecosystem has visibly matured over the past year — through community projects like the AI Module, the AI Agents framework, MCP server integrations, and the broader Drupal CMS 2.0 release. 2026 is the first year in which "Drupal + AI" is no longer a future bet but a working set of patterns several agencies are quietly building on. Three currents matter.
Tooling matured into the platform.
The community's AI module ecosystem on drupal.org now spans general-purpose AI integrations, an agents framework, and MCP server bindings that make Drupal addressable by any agent that speaks MCP. The aggregate result: AI capability is increasingly something a Drupal site can install rather than something it has to be built around.
The composition surface is changing.
Newer Drupal initiatives are pushing toward layout-and-content surfaces where editors compose with components rather than fields. AI-assisted content scaffolding inside those surfaces is becoming an editor expectation. Sites that don't move in that direction will feel a step behind within a year or two.
The agency model is being repriced.
Discovery, content modeling, and editorial onboarding — historically billable agency hours — are increasingly compressed by AI tooling. The work doesn't disappear; the unit shrinks. Agencies that productize the compression keep margin; agencies that don't lose it.
One sentence.
If there is one frame that holds the rest of this report together, it is this.
A lot of the work can be partially or fully automated — freeing the team to think about the harder, bigger problems.
The eighteen builds that follow are specific places where that automation can land — each grouped by the area of work where the savings happen, each named as a concrete thing Four Kitchens could ship.
Savings in engineering practice.
Where senior-engineer hours currently go: reviewing routine PRs, triaging dependency updates, repeating Drupal patterns across client projects, holding institutional context for repos no one else has touched. Four concrete builds reclaim that time.
An AI code reviewer on every PR.
The save: Routine PR-review hours per week, per repo.
Build: A GitHub Action that runs your existing drupal-ai-standards code-review skill against every PR opened against an FK client repo — posting structured review comments before a human opens the diff.
First milestone: One pilot repo, Action live for two sprints, count of human-review comments rendered unnecessary.
FIRE ai:* commands for senior-only chores.
The save: The repetitive analysis hours that block senior engineers from architecture work.
Build: New FIRE commands — fire ai:upgrade-deps, fire ai:security-audit, fire ai:scaffold-module, fire ai:pattern-lookup — that drive an AI agent through your standards and return a structured proposal for human approval.
First milestone: One command shipped (start with fire ai:upgrade-deps), used internally for a month, FIRE command schema documented.
A standing AI reviewer for single-author repos.
The save: The bus-factor cost of repos where institutional context lives in one person's head.
Build: A repo-specific AGENTS.md (filled in with commit-history particulars, intent decisions, conventions) plus a routine for keeping it fresh — applied first to the FK repos with the most concentrated authorship.
First milestone: Three internal FK repos picked, AGENTS.md filled in, one resilience review run with a non-author at the keyboard.
Bundle-classes as the project-start default.
The save: Untyped magic-string Drupal code that AI agents misread or break.
Build: A project-start ritual that wires drupal-ai-standards' bundle-classes skill into every new client build by default, plus a Sous-level default that generates bundle-classes for new content types.
First milestone: Next greenfield FK project ships with bundle-classes as the default pattern from day one.
Savings in project bootstrap.
Every new client engagement carries a setup tax: the first developer figures out the conventions, the AI tools each person uses, the project's particular Drupal model. That tax compounds across the firm. Three builds remove most of it.
Project-level AGENTS.md, populated on day one.
The save: The first-week ramp-up where a developer learns the project's particulars by asking other developers.
Build: A "scaffold-on-kickoff" ritual that runs drupal-ai-standards' setup prompt against every new client repo and fills in the project's content model, build commands, deploy targets, and gotchas.
First milestone: One client repo scaffolded end-to-end as a reference; the ritual documented as a checklist any PM can run.
Per-project AI tool config that ships in the repo.
The save: The "set up your IDE for this project" friction that happens silently and inconsistently.
Build: An extension of drupal-ai-standards' three-layer model to cover IDE rule files for Claude Code, Copilot, Cursor, OpenCode — checked into the repo, applied automatically on clone.
First milestone: Two IDE configs added to the scaffold (start with Claude Code + Copilot), used by every developer who works on a scaffolded project.
Project-specific onboarding skills.
The save: The Slack-DM tax — a developer asking "how does this client's [X] work?" and waiting hours for an answer.
Build: A skill-authoring template for project-onboarding skills (one per major client) that explains the domain, content model, deploy workflow, and known-good patterns.
First milestone: One client gets a full onboarding skill written; measured by handing the codebase to a new developer and timing gap to first commit.
Savings in sprint operations.
A meaningful slice of work that currently requires pulling a developer in — story decomposition, content modeling, migration analysis, status reporting, bug triage — can be partially or fully automated, with a project manager at the wheel rather than a developer. This is the largest opportunity in the report, both in hours saved and in scope to make uncomfortable changes. Five builds anchor it.
AI-drafted story decomposition.
The save: Developer hours spent in story-decomposition meetings.
Build: A "decompose this epic" skill that takes an epic and the project's existing ticket history, returns a draft story breakdown with acceptance criteria, sized against team velocity.
First milestone: One project tries the skill for one sprint; PM and engineering lead compare AI-drafted vs. human-drafted output.
AI-drafted content model proposals.
The save: Discovery hours spent building content models from scratch.
Build: A drupal-content-modeling skill that turns a content audit document into a draft content-type / paragraph / taxonomy structure for client review BEFORE developer kickoff.
First milestone: Used in one greenfield discovery, with the AI draft as the document the team reviews together.
AI source-data characterization for migrations.
The save: "We found out about [data quirk] in week 5" migration surprises.
Build: A drupal-migration-assistant skill that runs against source data, produces a structured characterization — schema, anomalies, scope of cleanup — that engineering uses to scope the work.
First milestone: Run against one upcoming migration's source data; output reviewed against what engineering would have found manually.
Self-drafting status reports.
The save: The 30-to-45-minute Friday-afternoon ritual of writing client status updates.
Build: A status-report skill that reads sprint state (tickets moved, PRs opened/closed, commits) and drafts a client-ready status note in FK's voice, for the PM to edit.
First milestone: One PM uses the skill for four weeks; measured by time-to-final-draft.
AI bug-triage first responder.
The save: The developer hour spent confirming a bug is real, where it lives, and how hard the fix is.
Build: A bug-triage skill with read access to the relevant repo that runs against incoming reports and returns a triaged ticket: reproduction status, suspected component, fix complexity estimate.
First milestone: Integrated into one client's bug intake; measured by how many tickets reach engineering pre-triaged.
Savings in editorial workflow.
Editorial workflow is where Four Kitchens already has the most external-facing AI exposure — AskYale, the higher-ed training engagements, the multisite accessibility work. The opportunity is to convert what FK currently delivers as bespoke service hours into continuous in-product capabilities. Three builds.
In-Drupal AI editorial assistant, packaged as a module.
The save: Repeated client editorial-AI implementations as bespoke work.
Build: A Four Kitchens Drupal module (or configuration recipe) that installs an in-CMS AI assistant — content scaffolding, headline alternatives, tone review, alt-text generation, accessibility audit on save — in one step on any client multisite.
First milestone: Module shipped to packagist; deployed to one higher-ed client multisite as the reference.
Hybrid AI editorial training.
The save: The hours your team spends delivering live training sessions, repeated per client.
Build: A training corpus (recorded core + reference docs) plus an editorial-onboarding skill that lets an editor ask "how do I do X in MY CMS, with MY content model?" — answered with project-specific context.
First milestone: One client's training delivered in the hybrid format; measured against the previous all-live version.
Cross-site accessibility crawler.
The save: The reactive "client reports a11y issue → engineer investigates" cycle.
Build: A scheduled crawler — grounded in drupal-ai-standards' 49-anti-pattern instruction set — that runs weekly across a client's sub-sites, surfaces issues with one-click remediation suggestions.
First milestone: Pilot crawler running against one higher-ed client's multisite for a month, with weekly issue digests.
Savings in delivery and maintenance.
Three builds at the firm level. Each reshapes a unit of work — what discovery is, what a deliverable is, what Continuous Care includes — rather than just compressing inputs.
AskYale as a productized starter.
The save: Custom AI-deliverable builds that repeat the majority of the AskYale work for each new client.
Build: An "ai-deliverable-starter" — the same shape Sous gives Drupal projects — distilled from AskYale's architecture (LLMs + RAG + Azure OpenAI), shipped as a repository template for future AI engagements.
First milestone: The starter exists as a runnable scaffold; one new AI engagement uses it to compress weeks off the build.
AI-compressed discovery sprint.
The save: The four-to-five-week discovery phase that currently precedes most engagements.
Build: A discovery toolchain — stakeholder-interview synthesis, content-audit drafting, competitive scan, brief drafting — that compresses the unit of "discovery" from weeks to a structured week.
First milestone: One client discovery run with the toolchain; consultant reports back on quality vs. status quo.
Continuous Care with AI standing watch.
The save: The reactive engineer hours triggered by routine platform-health issues an agent could surface earlier.
Build: A "platform-health" skill family that runs daily across Continuous Care client sites, surfacing only what warrants human attention; a clear human-vs-AI escalation rule set.
First milestone: Two Continuous Care clients pilot the hybrid model for one month, with measured incident catch rate.
A twelve-month rollout, in four phases.
The eighteen opportunities don't have to ship at once. They sequence naturally: foundation work that grounds the rest, the developer loop that proves the model internally, PM enablement that extends it past engineering, and finally the editorial and firm-level work that converts capability into deliverable. The dates below are illustrative — adjust to the cadence that fits your delivery commitments.
Four phases, each unlocking the next.
The rollout assumes Four Kitchens chooses to own this work — but every phase has a "buy the integration, build the standards" variant that trades development cost for time-to-value. We'd recommend discussing those branch points after Phase 1 is locked.
Open questions that would sharpen this report.
Every recommendation in this report is grounded in something we read in public — your repos, your team page, your conference talks. But there are seven questions we couldn't answer from outside, and the answers would meaningfully sharpen — or in some cases reshape — the recommendations.
-
Internal adoption of drupal-ai-standards.
We can see the repo, but not how many developers actively use it, on which projects, with which IDEs. The "fill in AGENTS.md per client" recommendation softens or intensifies depending on whether you're at 10% or 90% adoption today.
-
Operational state of AskYale today.
We can see the architecture — LLMs, RAG, Azure OpenAI — but not its current uptime, content volume, query rate, or whether other clients have followed. The "productize AskYale" opportunity depends on whether the original is still the right reference architecture.
-
Existence and shape of an internal AI usage policy.
You published a responsible-AI-use page externally. Inside the firm, what guides individual developers' choices about which AI tools to use on client work, with what data?
-
The current Continuous Care service shape.
The "Continuous Care + AI" recommendation assumes a baseline of what's in scope today. If the service has already evolved past where we can see it externally, the recommendation may already be partially shipped.
-
Bundle-classes adoption across client projects.
drupal-ai-standards includes a bundle-classes skill, but we can't tell how many client projects actually use bundle-classes as the default pattern vs. as an optional. The "AI-safe Drupal development" recommendation is one- or two-sided depending on the answer.
-
POTS vs. newer security tooling — current strategy.
POTS' AutoSec module still references gpt-3.5-turbo as its model, and that line has not been updated in years. Either POTS is being maintained at minimal cost while another tool takes over, or this is an out-of-date dependency in active use. Different recommendations follow.
-
FIRE command surface — actual usage.
FIRE is your standardized command set. The "FIRE ai:* commands" opportunity assumes the existing surface is well-used internally. We can see the repo; we can't see the usage.
What we read to write this.
Every observation in this report is grounded in a public source. Where the source is a Four Kitchens repository, the link goes to the relevant tree on GitHub. Where it is a third-party article or post, the link goes to the original. We did not fabricate, paraphrase, or extrapolate beyond what these sources explicitly state.
- drupal-ai-standards
- FIRE
- POTS
- Sous
- sous-recipe
- acquia-cloud-hooks
- Emulsify
- Four Kitchens team page
- Responsible AI Use Policy
- Drupal AI Module
- AI Agents framework
- Drupal CMS
For each opportunity in this report, our internal planning notes carry the specific paragraph or commit that grounds it. If a recommendation surprises — or doesn't match your read of the work — that's where we'd start the conversation.