Recipes submitted by Adobe community members: copy-and-paste AI prompts and workflows, with and without Adobe tools.
Recently active
AI agents write AEM unit tests fast, but a test that was generated and never run only proves the model wrote something plausible, not that the code works. AEM Test Gate is a Claude Code hook + skill, committed to the repo, that turns "write me a test" into a gated, verified loop: 1. Detect: a hook notices when a new class lands under src/main/java with no matching *Test.java, and starts the skill. Nobody has to remember to ask. 2. Classify and draft: it identifies the class as a Sling Model, OSGi service or Sling servlet and drafts a JUnit 5 test with the right AEM Mocks scaffold. 3. Gate 1: it asks before saving the test. 4. Gate 2: it asks before running ./mvnw test. 5. Repair: on failure it fixes the test, never the production class, at most twice, and flags a likely production bug instead of weakening assertions. 6. Prove: it reports pass/fail and JaCoCo coverage for the class. Two Python scripts work without any agent: test_gap_audit.py lists untested classes in any AEM Maven pro
[OVERVIEW] A Claude Code skill that reads a GitHub pull request and produces a structured first-pass review before a human opens the diff. You paste a PR URL. The skill pulls the metadata, the full diff and the inline review comments with the gh CLI, then returns a fixed-format review: summary, purpose, changes, impact, risks and updates needed. It checks the diff against your block library's conventions (block structure, design tokens, loading lifecycle, centralized analytics, authoring impact) and triages Copilot, CodeRabbit and Sonar comments as valid, partial, noise or needs verification. [TRYABLE] 1. Install the gh CLI and run gh auth login with access to your repo 2. Save the SKILL.md as .claude/skills/pr-review/SKILL.md in your project 3. Edit the "Convention violations" list in step 3 of the skill to match your block library 4. In Claude Code, ask: review https://github.com///pull/ 5. Read the review and check any item marked Verify 6. Edit it and post whatever you want to sen
[OVERVIEW] As a product manager working with Adobe Experience Platform and Adobe Journey Optimizer, I regularly translate marketing requests into product requirements that engineering teams can evaluate and build against. AI has become a useful part of that process, particularly for identifying missing requirements, researching Adobe capabilities, and turning business conversations into structured documentation. I've developed a three-stage workflow using ChatGPT to help with requirements discovery, PRD generation, and quality review. The goal isn't to have AI make product decisions. It's to reduce the manual effort of documenting requirements while improving their clarity, consistency, and testability. [TRYABLE] Stage 1: Requirements Discovery Start with a business request, even if it's incomplete. ChatGPT reviews the request, identifies gaps, researches relevant Adobe capabilities using official documentation when available, and asks up to five targeted clarification questions.
[OVERVIEW] A saved Coworker skill that turns a Customer Journey Analytics finding into a ready-to-paste annotation. After you run any CJA analysis (e.g. anomaly detection on a daily metric), you say "create an annotation" — or "annotate this" / "make an annotation", optionally naming the finding ("annotate the May 31 drop") — and Coworker returns a formatted table with every field the CJA annotation form needs: Name, Description (with actual vs. expected numbers and % change), Data view + ID, date/range, exact metric and dimension names + component IDs, segments, a suggested color, and whether to apply it to all panels. Because it reuses the exact component names and IDs from the analysis, the values paste straight into CJA without re-lookup. It formats the annotation for manual entry; it doesn't write to CJA via API. [TRYABLE] Save this as a personal Coworker skill (Skills settings → create a skill), then: Run a CJA analysis in Coworker — e.g. "Run anomaly detection on daily occurre
[OVERVIEW] A saved CX Enterprise Coworker skill that produces a monthly health check on your Adobe Experience Platform data, how fresh it is and how reliably it's arriving, for any set of datasets you name. One request generates interactive dashboards in chat plus a downloadable, Adobe-branded PDF. It knows the difference between event/streaming datasets (like Web SDK and Mobile SDK) and profile datasets, and reports the right metrics for each. [TRYABLE] 1. Ask Coworker to build a monthly data-health/latency dashboard for your datasets, and refine it until the dashboards and PDF look right. 2. Say "save this as a skill." Confirm how you want to trigger it, what it outputs by default, and its default sandbox and month. 3. Review the draft and publish, it's then available in every future session. 4. Run the quick test to confirm it works, then just ask for the dashboard each month (naming the month or datasets when you want to override the defaults). [SETUP] - CX Enterprise Coworker wi
[OVERVIEW] I pointed Claude, connected to my Workfront instance through the Workfront MCP connector, at Adobe’s Experience League article “Create a review and approval dashboard” and asked it to build that dashboard. (This might also work with Coworker but I haven't tried) It read the article, worked out the field paths for each widget, and created a canvas dashboard with 4 KPIs, 2 bar charts and 2 tables. Where the API couldn’t reproduce something in the article exactly, it substituted and told me what it changed. The same approach works for any dashboard Adobe publishes: give it the article URL, then check the result in the UI. I later rebuilt the same dashboard in a second instance, and Claude reused the config without re-resolving anything. As someone who manages multiple instances, there is no way to duplicate a canvas dashboard into each instance -- you can only rebuild it, so without AI, I would be forced to spend an hour or two on each rebuild. Additionally, this is menia
AI coding tools are fast at writing Edge Delivery Services (EDS) block CSS, but they quietly break the design system: a hard-coded #dadada here, a made-up var(--color-brand-accent) there, and sometimes a stylelint-disable comment to make the error go away.This recipe splits the work between AI and scripts:• Design tokens live in one tokens.json file (W3C DTCG format). A small Node script writes them into styles/styles.css as CSS variables. There's no runtime build step, nothing extra ships to the browser, and authoring in Document Authoring / Experience Workspace is unchanged.• Quality gates in "npm run verify" (Stylelint, ESLint, Node's built-in test runner) fail the build when anyone hard-codes a color, uses a variable that doesn't exist, hand-edits the generated CSS, disables the color lint rules, or picks token colors that fail WCAG AA contrast.• A Claude Code skill (/apply-design-tokens) does the judgement work. It maps each hard-coded value to the right token by role, not by near
[OVERVIEW] I built a brand bot agent to review and revise copy to align with brand guidelines. It solves the need for many iterations of copy across marketing materials with a limited bandwidth copywriting team. It was originally built as a custom GPT in ChatGPT and then has been reused as an agent in Copilot and event used as a Task Collaborator agent in Workfront! It works by reviewing the users provided copy or even drafted copy and returns an updated output that is fully aligned with brand guidelines. [TRYABLE]# [INSERT BRAND NAME] Brand Bot Custom GPT Instructions## Role & ExpertiseYou are the most powerful **copywriter, proofreader, and brand expert** at [INSERT BRAND NAME], with complete knowledge of the brand voice, style guidelines, and marketing standards. You will assist users across all departments, but mainly [INSERT PRIMARY DEPARTMENTS], in perfecting or creating content that aligns with the [INSERT BRAND NAME] brand. Content will mainly be for [INSERT PRIMARY CONTENT
OVERVIEW]An AI-assisted workflow to ensure parity in derived field components across data views/connections[IMPACT]Eliminate variance in derived field components across data views/connections.[LESSONS]Not included[TRYABLE]CJA derived fields require logic to define desired metrics and dimensions. This logic must be translated from business requirements and small variance in logic can result in unexpected variances in data.Additionally, derived fields are specific to each connection. This means they must be recreated in other connections. For example, a derived field in a prod connection is completely separate from one in a dev connection. This can easily lead to variances in the derived field definition and/or component settings which can also cause variance in data.Ensure Derived Field/Component Meets Business Requirements1. Build out the derived field2. Add to a data view and configure appropriately3. Use the Auto CJA SDR tool to download the components JSON definition4. Use a company
[OVERVIEW] Most AEM testing starts after the content exists. Very little of it covers what an author actually does: insert a component, fill in a dialog, save. This framework uses Claude Code and Playwright to cover that gap in the Touch UI editor. It has three Claude Code commands.The first reads your AEM project and proposes where tests should create pages and insert components. The second compares what a dialog promises with what the Sling Model and HTL enforce. The third turns a chosen case into a Playwright test that drives the real editor, then runs it and fixes selectors from the trace. When a failure looks like intended behaviour or a product bug, the agent stops and asks instead of working around it.It works on any AEM project that uses the Touch UI page editor. The repo ships with WKND as a working example.[TRYABLE]Clone the repo, then run npm install and npx playwright install chromium Try it on WKND first: install WKND on a disposable local AEM SDK author and run npm test.
[OVERVIEW] An AI-assisted content migration solution that automates the end-to-end migration of content from non-AEM sources into Adobe Experience Manager. The solution works in three stages: Site Crawling - Automatically crawls the source website to extract all relevant content Structured Transformation - Converts the crawled content into a structured JSON format Intelligent Mapping & Migration - An auto-generated AEM servlet maps the JSON content to existing AEM components and templates, executing the full migration without manual intervention Claude was used to generate the migration scripts, significantly reducing development effort and accelerating delivery. [TRYABLE] 1. Define your AEM component/template inventory - Export or document the list of available AEM components and templates that content will be mapped to 2. Prepare your Claude prompt - Provide Claude with the source site URL, the target AEM component structure, and a sample JSON schema as context 3. Run the site
[OVERVIEW]Built an AI-assisted prototype-to-production workflow for AEM Edge Delivery Services. It enables teams to rapidly prototype experiences with AI, then convert them into governed, reusable, authorable EDS components with the right design system, content models, Universal Editor support, and QA.[IMPACT]Key outcomes:- Faster transition from an idea or design concept to a working experience.- Less rework between design/prototyping teams and AEM engineering teams.- Greater reuse of existing Edge Delivery components instead of continuously generating new ones.- More consistent application of the design system and AEM authoring patterns.- Earlier identification of accessibility, SEO, performance, and component-design issues.- A repeatable handoff model that allows teams to benefit from AI-generated code without treating that code as production-ready by default.[LESSONS]Treat AI-generated code as an accelerator, not the architecture. Map prototypes to existing EDS components first, ke
[OVERVIEW] A Claude Code/command that copies content between two local AEM instances, directly on disk, with both instances shut down. It’s for the moment you drop a fresh AEM SDK QuickStart and need your existing local content in it — no content packages, no Package Manager. You give it a source and a target; it builds and runs the Jackrabbit oak-upgrade sidegrade, asks before anything destructive, and verifies the result. [TRYABLE] 1. Drop oak-migrate.md into .claude/commands/ in your project 2. Get an oak-upgrade jar (mvn dependency:get -Dartifact=org.apache.jackrabbit:oak-upgrade:2.6.0:jar), plus oak-run for verification 3. Run the discovery step once to list your real /content, /content/dam and /conf roots, then edit the path list in the command file 4. Shut down both AEM instances 5. Run /oak-migrate — optional: --merge, --with-versions, --verify 6. Approve the command when it asks, and answer the datastore question (copy binaries vs. shared) 7. Check the verification output: e
[OVERVIEW]When you upgrade from Adobe Analytics to Customer Journey Analytics, Adobe CX Enterprise Coworker can compare the data in both systems for you in a single conversation. You pick a report suite and a data view, choose whether to check one metric, one dimension, or everything at once, and Coworker reports how closely the two match, with insights and suggested next steps. You do not need to know how your implementation is architected, and there is no need to build queries or export data by hand.[IMPACT]Validating an upgrade comes down to knowing how closely your Customer Journey Analytics data matches your Adobe Analytics data, and where it does not. The output is an overall matching rate, key insights, a summary of totals and variance, and, depending on what you validate, a daily trend, date-level detail, or a scorecard, followed by likely causes and suggested actions. For example, in a scenario where you compare page views over the past 30 days and Customer Journey Analytics r
[OVERVIEW]You can check the quality of the data in your Adobe Experience Platform datasets with a plain-language prompt in Adobe CX Enterprise Coworker. It gives you a quick read on whether a dataset or a single field can be trusted, without writing SQL queries or digging through complex schema hierarchies. Coworker uses its Data Validation skill to run statistical and semantic checks on a sample of your data and returns the results in the same conversation. The skill is read-only, so it flags potential issues without changing your data, schemas, or mappings.[IMPACT]Use it for a fast quality check on a dataset or a field, for example after a new implementation or an implementation update, or as an ongoing check on a critical dataset to catch regressions early. The output is a results table with one row per field showing the share of valid, distinct, and null values, the most common values, the most common invalid values with an explanation, and a short note on the field's quality, foll
[OVERVIEW]Adobe CX Enterprise Coworker can take you from a full operational view of your Adobe Experience Platform environment to a newly built audience in a single conversation. This is a way around the manual, time-consuming audit of how your audiences, journeys, datasets, and destinations connect. Coworker generates that view on demand, benchmarks it against an industry blueprint from Experience League, and then builds a new audience from a plain-language description, with you confirming the choices along the way.[IMPACT]You get your bearings in an Experience Platform environment, see where the gaps are, and act on them without writing queries. The output is a report on how audiences and journeys connect, with a health summary and recommended next steps, a benchmark showing where you are doing well and where the gaps are, and a new audience built from a plain-language description. For example, in a scenario where the report shows journeys with no audiences attached, that is a gap wo
[OVERVIEW]This workflow shows how to use Adobe CX Enterprise Coworker to go from a simple question about your web analytics data to an investigated root cause in a single conversation. You skip the jumping between reports, building queries, and manually slicing data to find patterns. It starts with a broad exploration question, narrows to a trend on whatever stands out, and then asks Coworker to explain a pattern in that trend, all using Customer Journey Analytics data.[IMPACT]The goal is to move from a basic data question to an explained pattern without building queries by hand. The output is a visualization and table with key takeaways, a trended graph of the metric you chose, and an explanation of a recurring pattern in it. For example, in a scenario where traffic to a page shows recurring dips, the investigation could point to a repeating three-day cycle that lines up with a coordinated marketing campaign cadence, not a day-of-week effect.[LESSONS]Starting with a broad question giv
[OVERVIEW]Four plain-language questions in Adobe CX Enterprise Coworker can show where customers drop off before purchase. In practice, you describe what you want to know, such as where people are lost on the way to purchase, and Coworker picks the funnel, runs it on your Customer Journey Analytics data view or Adobe Analytics report suite, and suggests where to look next. You do not need to know which visualization to use. Each answer leads into the next question: find the biggest drop-off, check whether marketing channel explains it, check device type, then ask what to do about it.[IMPACT]What you are after is where in the purchase path customers are lost and which segment accounts for it, without building a fallout visualization by hand. The output is a funnel showing drop-off at each step, channel and device breakdowns of the biggest leak, and a recommendation on what to prioritize. Adobe's worked example, which uses sample data for a fictional retailer, follows this same path. It
[OVERVIEW]I have created a skill for creating Junit tests in AEM.[IMPACT]This should help to generate the good quality junit tests that are referenced from the official Adobe sources and the open source projects such as WCM.io.[LESSONS]The skill creator within Codex has been great at pointing the issues and best practices. Originally I had built this using Claude Code and has revamped it based on the feedback from Codex.[TRYABLE]```bash# Show helpnpx aem-junit-skill help# Show full guidenpx aem-junit-skill guide# Get Maven dependenciesnpx aem-junit-skill deps# Generate test templatenpx aem-junit-skill template modelnpx aem-junit-skill template servicenpx aem-junit-skill template componentnpx aem-junit-skill template servlet```[SETUP]This can be installed in Codex, Claude or Github Copilot.[SAMPLE_OUTPUT]https://github.com/narendragandhi/aem-junit-skill
[PROBLEM]Getting honest, challenging feedback on an idea before you take it to leadership or your team.[OVERVIEW]I've learned this from Jay Schwedelson's Eventastic 2026 event, where he shared the best prompt he's used for gathering feedback. It turns an AI tool into a live Board of Directors that debates your idea, challenges weak thinking, and ends every response with a direct question for you.[TRYABLE]Act as my live Board of Directors made up of:[Insert 4-5 names]This should feel like a REAL ongoing boardroom conversation that I am actively part of. Do NOT give polished summaries or long essays.Instead:- Make the conversation feel live, messy, opinionated, and unscripted- Let board members interrupt, disagree, react emotionally, joke, and challenge weak thinking- Only let 1-3 people respond naturally at a time- Each person should sound distinct and think differentlyMOST IMPORTANT: The conversation should NEVER fully end.At the end of EVERY response:- ONE specific board member must a
[OVERVIEW]I built a five-layer context system to stop AI coding assistants from guessing their way through AEM work. Copilot, Claude Code, Cursor - they're all capable, but without knowing how a specific project is put together they fall back on generic training data, and you end up reworking half of what they produce in review. So instead of repeating context in every prompt, I layered it: an AGENTS.md file at the repo root (generated with Adobe's ensure-agents-md skill via npx skills --plugin github-copilot) covering the project's purpose, structure, and build/test commands; smaller scoped instruction files for specific concerns, like .agents/instructions/testing.junit5.md for test conventions; Adobe's own vendor skills (Cloud Service, 6.5 LTS, or EDS depending on the project) for baseline best practices around components, dispatcher config, and OSGi; custom skills for the corrections I found myself making over and over; and a shared, versioned prompt library so the team isn't reinve
[OVERVIEW]I built this prompt to help turn a complex business or technical requirement into a clear Adobe solution design.The idea is to avoid jumping straight into a product feature or implementation. The prompt first breaks down what the business is actually trying to achieve, then looks at the data, platform responsibilities, constraints, and the best way to structure the solution across the relevant Adobe capabilities.It also asks the AI to explain why the most obvious approach may not work, use official Adobe documentation to support the analysis, and challenge its own recommendation before producing the final design.The output can then be used as the basis for a technical discussion or turned into a concise, slide-ready solution.[IMPACT]The main goal was to make solution design more structured, especially when a requirement involves several Adobe products or capabilities and it is not immediately clear where each responsibility should lie in it.I wanted the prompt to help move fr
[OVERVIEW]I built a reusable prompt to support technical architecture and integration assessments using AI.The prompt helps evaluate whether a proposed integration is not only technically possible, but also the right architectural choice. It compares direct integration, middleware, specialized services, and other alternatives while considering security, scalability, maintenance, ownership, and separation of responsibilities.A key part of the recipe is the double challenge: the AI must first question the initial technical assumption and then challenge its own preferred recommendation before reaching a conclusion.The analysis is also grounded primarily in official vendor documentation, clearly separating documented capabilities from architectural recommendations and assumptions that still require validation.The prompt is platform-agnostic and can be reused for different enterprise integration scenarios.[IMPACT]The goal was to use AI as a critical architecture assistant, rather than simpl
[OVERVIEW]Adobe's open-source AEMCS CDN Log Analysis Tooling ships an ELK stack and four prebuilt Kibana dashboards for analyzing AEM as a Cloud Service CDN logs. The dashboards answer the questions they were designed for - cache hit ratio, traffic, WAF. Everything else means hand-writing Elasticsearch Query DSL or building a new visualization, which is slow even if you know the syntax and a hard stop if you don't.I added an optional Elasticsearch MCP server to that stack, so you can point Claude Code, OpenAI Codex or GitHub Copilot at your indexed logs and just ask: "which client IPs came closest to the X requests/second rate limit, and when were the peaks?" The agent writes the query, runs it, and shows you the query it used so you can check it.It runs as one more container behind a Docker Compose profile, so docker compose up -d behaves exactly as before and nobody who doesn't want it is affected. Enable it with docker compose --profile mcp up -d. The endpoint binds to localhost onl
[OVERVIEW]I built an AI-powered framework that helps review and improve strategy recommendations before stakeholder meetings. Instead of relying only on my own perspective, I use AI to challenge assumptions, identify risks, suggest alternative approaches, and highlight potential stakeholder concerns. This helps create stronger recommendations, improves presentation quality, and increases confidence when making important decisions.[IMPACT]My goal was to improve the quality of strategy recommendations before stakeholder discussions. By using AI to review ideas, identify risks, and suggest improvements, I was able to prepare more confidently and reduce the time spent on manual analysis. The framework helped create more structured recommendations, identify potential concerns early, and improve overall presentation quality and decision-making.[LESSONS]Using AI works best when the context and goals are clearly defined. I learned that detailed prompts produce more accurate and actionable feed
Already have an account? Login
Enter your E-mail address. We'll send you an e-mail with instructions to reset your password.