Org Skills

Designs and builds AEM Assets as a governed DAM on AEM as a Cloud Service — folder and taxonomy structure, metadata schemas and profiles, processing profiles and renditions, asset delivery through Dynamic Media and the Assets OpenAPIs, Bulk Import, Asset Compute microservices, and large-collection performance.

Write production-grade Adobe Experience Manager back-end Java for AEM as a Cloud Service (6.5 differences noted) — OSGi Declarative Services, runmode configs with env vars and secrets, Sling servlets and filters, service users via repoinit, outbound HTTP with timeouts, queries and custom Oak indexes, Sling Jobs, workflows and replication.

Builds Adobe Experience Manager Sites components — HTL with correct XSS contexts, Sling Models and JSON exporters, Core Components proxies and the delegation pattern, Granite UI dialogs and multifields, editable templates, policies and the Style System, i18n and component clientlibs.

Builds sites on AEM Edge Delivery Services (aem.live) — boilerplate setup, content sources (Google Drive, SharePoint, Document Authoring, AEM with the Universal Editor), blocks, the eager/lazy/delayed loading phases, spreadsheets and query-index, preview and publish, RUM and experimentation, with a 100 PageSpeed score as the bar.

Builds Adobe Experience Manager Sites front-end code — the archetype ui.frontend webpack build, client libraries and categories, Style System CSS and design tokens, the responsive grid, JavaScript that survives the page editor, the Cloud Manager front-end pipeline and Site Themes, images and fonts, and Core Web Vitals on an AEM page.

Designs and builds headless content delivery on AEM as a Cloud Service — Content Fragment Models as the schema, GraphQL persisted queries as versioned endpoints, CDN and dispatcher caching, CORS, authentication, the Content Fragment Delivery OpenAPI, and front-end consumers.

Builds and instruments applications for the Universal Editor — the in-context authoring surface for AEM Sites pages, Edge Delivery Services sites and headless front ends.

Designs Adobe Experience Manager solution architecture and writes the decision record — Cloud Service vs 6.5, delivery model (HTL Sites, headless Content Fragments + GraphQL, Universal Editor hybrid, Edge Delivery Services), repository and package structure, MSM and translation, integrations, caching and personalization, identity, environments and NFRs.

Writes and debugs AEM Dispatcher and Adobe CDN configuration — flexible-mode file layout, deny-by-default filters, cache rules, ignoreUrlParams and statfileslevel, invalidation and CDN purge, TTLs and ETags, rewrites, redirects and vanity URLs, security headers, CORS, permission-sensitive caching, and cdn.yaml traffic filters and WAF.

Diagnoses and fixes Adobe Experience Manager slowness by layer — CDN and dispatcher hit ratio, uncacheable requests, slow JCR queries and missing Oak indexes, heavy Sling Models and HTL, blocking external calls, Sling Dynamic Include, Core Web Vitals, and author-side backlogs.

Designs a test strategy for Adobe Experience Manager projects and writes the tests — JUnit 5 with AEM Mocks for Sling Models, OSGi services, servlets, job consumers and workflow steps; integration tests with the AEM testing clients; UI tests in Cloud Manager; front-end and Edge Delivery block tests; headless persisted-query contract tests; and the coverage and OakPAL gates.

Reviews AEM code changes — pull requests, diffs or content packages — against a severity-ranked checklist covering security and XSS contexts, resource handling, performance and cacheability, Sling Models, OSGi services, components and dialogs, Cloud Service compatibility, package filters and index names, dispatcher and CDN rules, headless and Universal Editor concerns, tests and accessibility, and returns a findings table with a merge verdict.

Designs and debugs CI/CD, environments and release flow for AEM as a Cloud Service with Cloud Manager — pipeline types and quality gates, Git provider setup and its limitations, Maven build rules and package structure, environment variables and secrets, repoinit and index deployment, config pipelines for CDN and log forwarding, RDEs and the local SDK, logs, releases and rollback.

Plans and executes a migration from AEM 6.x (on-prem or managed services) to AEM as a Cloud Service — readiness assessment, code refactoring, content transfer, identity, cutover and risk.

Designs and hardens security for AEM as a Cloud Service across the whole stack — author access through Adobe IMS and Admin Console product profiles, principal-based ACLs and service users in repoinit, closed user groups and permission-sensitive caching, CDN traffic filter and WAF rules, purge keys, secrets and OSGi configuration values, CSRF, and security headers including CSP for client libraries.

Always-on rules for AEM as a Cloud Service Java bundles, HTL components, OSGi configs, front-end clientlibs and dispatcher configuration.

Write production-grade C# and ASP.NET Core services on .NET 10 (with .NET 8 notes) — minimal APIs vs controllers, DI lifetimes, options and secrets, async/await with cancellation, nullable reference types, validation with AddValidation, ProblemDetails errors, EF Core usage, IHttpClientFactory with the standard resilience handler, structured logging, JWT and policy authorization, background services and built-in OpenAPI.

Design and structure .NET back-end solutions — modular monolith versus separate services, solution and assembly boundaries, vertical slices versus a layered domain, aggregates and data ownership, multi-tenancy isolation, CQRS and mediator trade-offs, hosting model (container, serverless, Aspire), where cross-cutting concerns live, and the ADR that records the decision.

Diagnose and fix performance problems in .NET and ASP.NET Core services — measure first with dotnet-counters, dotnet-trace, dotnet-gcdump, BenchmarkDotNet and OpenTelemetry, then fix thread-pool starvation and sync-over-async, slow EF Core queries, allocation-heavy hot paths, leaking caches, connection-pool exhaustion, GC pressure and slow start-up.

Design a .NET test strategy and write the tests — xUnit v3 conventions, unit tests of domain logic, ASP.NET Core integration tests with WebApplicationFactory and Testcontainers, a test authentication handler, faking outbound HTTP, resetting data between tests, mocking only what you do not own, contract and architecture tests, coverage, flaky-test triage and CI.

Always-on rules for writing C# and ASP.NET Core services, project files and configuration.

Build production-grade Node.js back-end services in TypeScript — framework choice (Fastify, NestJS, Express, Hono), ESM and strict tsconfig, schema validation at the edge with Zod 4 or TypeBox, typed domain errors mapped to problem+json, a validated config module, data access with Prisma 7, Drizzle or Kysely, outbound HTTP with timeouts and idempotency, auth, pino logging and background jobs.

Design the structure of Node.js/TypeScript back-end systems — modular monolith versus separate services, feature modules and ports-and-adapters, NestJS modules versus Fastify plugins, dependency injection and the composition root, data ownership, multi-tenancy, where authentication and caching sit, containers versus serverless, monorepos with pnpm workspaces, Turborepo or Nx, and the ADR that records it.

Diagnose and fix performance problems in Node.js back-end services — event loop blocking and lag, high p99 latency, low throughput, CPU hot paths, memory leaks and OOM kills, stream backpressure, JSON serialisation cost, connection-pool exhaustion, missing keep-alive and container CPU throttling.

Design the test strategy for a Node.js/TypeScript back-end service and write the tests — runner choice between Vitest, Jest and node:test, in-process HTTP tests with Fastify inject or supertest, real Postgres and Redis through Testcontainers, outbound HTTP faked with MSW or undici MockAgent, database isolation per test, fake timers, factories, contract tests, coverage and flaky-test triage.

Always-on rules for writing Node.js back-end services in TypeScript or JavaScript.

Plan and write relational schema changes that deploy without downtime or data loss in any back-end stack — expand/contract sequencing, lock-safe DDL per engine, backfills over large tables, online index builds, migration tooling (EF Core, Prisma, Drizzle, Flyway, Liquibase, Alembic), and what rollback actually means once data has moved.

Design HTTP APIs in any back-end stack and own the contract rules for this catalog — resource modelling and naming, methods and status codes, RFC 9457 problem+json errors, cursor versus offset pagination, conditional GET and caching, idempotency keys, ETag concurrency, versioning with RFC 9745 Deprecation and RFC 8594 Sunset, long-running operations, webhooks, rate limiting and an OpenAPI-first workflow with Spectral and oasdiff.

Design reliable asynchronous messaging between services or modules in any back-end stack — transactional outbox, inbox and idempotent consumers, at-least-once delivery, event schema versioning, retries with backoff and dead-letter queues, ordering per key, and sagas versus a workflow engine.

Review server-side changes and deliver severity-labelled findings with concrete fixes and a merge verdict — correctness under concurrency, transactions and idempotency, authorization and injection, data migrations and rollout order, API and message contracts, resilience, performance, observability, tests and supply chain.

Make a back-end service safe to run in production in any stack — liveness and readiness probes that mean different things, graceful shutdown and connection draining, OpenTelemetry traces, metrics and logs with correlated context, structured logging without leaking personal data, useful health and dependency checks, container image and resource limits, and the signals an on-call engineer actually needs.

Write production-quality Angular code day to day — standalone components with signal inputs and outputs, computed, linkedSignal and effect used correctly, @if/@for/@switch/@defer/@let templates, Signal Forms (typed Reactive Forms on existing code), httpResource/resource and HttpClient services, inject() and @Service, lazy routes with input binding, directives, pipes, Material, CDK, Angular Aria, styling and accessibility.

Designs the structure of Angular applications — feature-first folders with public APIs and lint-enforced boundaries, file-naming convention, state scope (signals, NgRx SignalStore, NgRx Store), RxJS boundaries, dependency-injection and route design, UI library choice (Material, CDK, Angular Aria, PrimeNG), authentication, runtime configuration, i18n, error monitoring, Nx monorepos and micro-frontends, recorded as ADRs.

Design and build server-side rendering, prerendering and hydration for Angular — per-route `RenderMode` in `app.routes.server.ts`, `provideServerRendering(withRoutes(...))`, `getPrerenderParams`, `provideClientHydration()` with incremental hydration and `@defer (hydrate on …)`, the HTTP transfer cache, browser-only code with `afterNextRender`, `outputMode`, `AngularNodeAppEngine` and CDN caching.

Diagnose and fix Angular runtime and load performance — change detection doing too much work, template work on every check, oversized bundles, slow LCP and high INP, janky lists and tables, memory growth from undisposed subscriptions.

Design and write tests for Angular code — Vitest via the `@angular/build:unit-test` builder, component tests with Angular Testing Library and TestBed, CDK component harnesses, `HttpTestingController`, signals, Signal Forms, `httpResource`/`resource`, NgRx SignalStore, guards, interceptors and pipes, plus Playwright end-to-end journeys.

Plan and execute Angular upgrades and modernisation — `ng update` one major at a time, NgModule to standalone, `*ngIf`/`*ngFor` to built-in control flow, constructor DI to `inject()`, decorators to signal inputs, outputs and queries, eager to lazy routes, `CommonModule` and `ngClass`/`ngStyle` removal, zone.js to zoneless, Karma to Vitest, `@angular/animations` to `animate.enter`/`animate.leave`, and Reactive Forms to Signal Forms.

Always-on rules for writing and editing Angular application code and templates, matched by folder so they apply under both the current and the legacy file-naming convention.

Always-on browser-security rules for client-side code in any frontend stack — bundle secrets, XSS sinks, URL and redirect handling, postMessage, CSP, CSRF with cookie sessions, token storage and third-party scripts.

Write production-quality React 19.2 web code day to day — function components with ref as a prop, hooks and effects done right (useEffectEvent, use, Activity), forms with React Hook Form + Zod or Server Actions with useActionState, data via TanStack Query v5, React Router v8 loaders or Next.js 16 Server Components with use cache, Suspense and error boundaries, accessibility, and the purity rules the React Compiler needs.

Architect-level guidance for structuring React web applications — framework choice (Next.js 16 with Cache Components, React Router v8 framework or data mode, TanStack Start, Vite SPA), feature-first folder layout, state management chosen by lifetime (TanStack Query, URL, Zustand, Jotai, Redux Toolkit, Context), data layer and API contracts, routing and code splitting, auth and security boundaries, monorepos and design systems, and architecture decision records.

Diagnose and fix React web performance problems by measuring first — slow renders and re-render storms, poor Core Web Vitals (LCP, INP, CLS), slow TTFB on Next.js 16, large bundles, janky long lists and memory leaks — using React Performance Tracks, the React DevTools Profiler, web-vitals attribution, React Compiler bail-out lints, virtualisation, Activity, transitions and 'use cache'.

Design a React web test strategy and write the tests — Vitest 5 with React Testing Library in jsdom or Browser Mode, MSW 2 for the network, testing hooks, Suspense and error boundaries, async Server Components and Server Actions, Storybook 10 play functions with the Vitest addon, and Playwright journeys.

Always-on rules for writing and editing React web components and hooks in TypeScript.

Write production-quality React Native and Expo screens day to day — Expo Router routes and Stack.Protected guards, StyleSheet or NativeWind with theme tokens, safe areas and keyboard handling, FlashList v2 lists, Pressable and touch targets, forms with React Hook Form + Zod, Expo SDK modules and permissions, and gestures and animations with Reanimated 4.

Architect-level guidance for React Native and Expo apps — Expo managed vs bare vs brownfield, Expo Router structure and auth boundaries, state and offline-first data with TanStack Query, MMKV, SecureStore and SQLite, native module strategy, monorepo code sharing with web, theming and i18n, observability, and release engineering with EAS Build and EAS Update.

Diagnose and fix React Native and Expo performance by measuring first — slow cold start, dropped frames and janky FlashList scrolling, laggy gestures and animations, a blocked JS thread, long interactions, growing memory, and oversized JavaScript bundles or updates — with React Native DevTools, the Perf Monitor, Android Studio system traces, Perfetto, Instruments and Expo Atlas.

Design a React Native / Expo test strategy and write the tests — Jest with the jest-expo preset, React Native Testing Library queries and userEvent, mocking Expo modules, Reanimated and MMKV, faking the network with MSW, routing tests with renderRouter from expo-router/testing-library, and Maestro end-to-end flows on EAS Build.

Always-on rules for writing React Native and Expo screens, components and hooks in TypeScript.

Review client-side changes in any frontend stack (React, React Native, Angular, Salesforce LWC, plain TypeScript, CSS) and deliver severity-labelled findings with concrete fixes and a merge verdict — correctness, architecture boundaries, types, accessibility, styling, SSR and hydration, security, performance, tests and maintainability.

Write and split product backlog items that a team can estimate, build and test - INVEST checks, story splitting patterns, "As a / I want / so that" wording, Given/When/Then acceptance criteria, Definition of Ready and Done, and the mapping to Azure Boards work item types and fields (System.Description, Microsoft.VSTS.Common.AcceptanceCriteria, HTML formatting).

Reviews code, configuration and pipelines for exploitable security weaknesses against the OWASP Top 10:2025 and the OWASP API Security Top 10 2023, and reports each finding with evidence, an attacker, an exploit scenario, a severity and a framework-native fix.

Turns an Azure DevOps work item into a reviewed, step-by-step implementation plan grounded in the current codebase, without editing any code or changing the work item.

Turns a feature idea, PRD, meeting notes or bug report into well-formed Azure DevOps Features, User Stories and Tasks with Given/When/Then acceptance criteria; drafts first and creates work items only after you confirm in a follow-up turn.

Explains why an Azure Pipelines build failed - reads its status, logs and associated changes, names the failing step or test and the likely commit, PR and work item, and proposes a fix, without re-running or changing anything.

Reviews the current branch's changes or an Azure DevOps pull request and returns severity-ranked findings with file:line locations, concrete fixes and a merge verdict, without changing code or posting to the PR.

Writes a pull request title and description from the branch diff and the linked Azure DevOps work item - summary, AB# links, changes by area, how to test, test evidence and rollout notes - as text you paste into the PR; it never updates the PR itself.

Produces user-facing release notes plus an internal risk and rollout section for a tag range, branch, date range or Azure DevOps build, tracing every entry to a merged PR, work item or commit, without changing anything.

Performs a focused security review of a pull request, branch or code area against the OWASP Top 10 and API Security Top 10, reporting each finding with evidence, an exploit scenario, severity and a fix, without changing code or touching live systems.

Writes or improves tests for the code you point at or your current changes, runs the project's test command until green (bounded retries), and maps coverage to the work item's acceptance criteria; touches test files only.

Always-on conventions for work item links, branch names, commit messages, pull requests and pipeline YAML in Azure DevOps repositories.

Always-on security rules for source and configuration files in every language — secrets, input handling, access control, sessions and tokens, data protection, dependencies, and when to stop and ask a person.

Always-on, stack-neutral TypeScript rules — strictness, typing untrusted input, async correctness and safe narrowing.

Connects GitHub Copilot and Claude Code to Azure DevOps (work items, pull requests, pipelines and builds, wiki, test plans, Advanced Security alerts) through Microsoft's Azure DevOps MCP server, read-only by default; the catalog's agents reach it under the server name `ado`.

Write production-grade Salesforce Apex for Spring '26 — one-line triggers with a handler/service/selector layering, bulkified SOQL and DML, USER_MODE security, governor-limit-aware design, async Apex (Queueable with AsyncOptions, Batch, Apex Cursors, Schedulable, Platform Events), invocable methods for Flow and Agentforce, error handling and logging.

Build Lightning Web Components for Spring '26 — the data-access ladder from `lightning-record-form` and Lightning Data Service to wired and imperative Apex, composition and events, `lwc:if`/`for:each`/`lwc:ref`/`lwc:on`, dynamic components, refreshing with `refreshApex`, `notifyRecordUpdateAvailable` and `RefreshEvent`, Lightning Message Service, `js-meta.xml` targets and `targetConfigs`, Flow screen and Experience Cloud components, SLDS 2 styling hooks, accessibility and Lightning Web Security.

Design and build Salesforce automation for Spring '26 — choosing between record-triggered, scheduled, screen, autolaunched and platform-event-triggered Flow, Apex triggers, Flow Approval Processes and Flow Orchestration; before-save vs after-save, entry conditions, Trigger Order, bulk-safe flow patterns, the Custom Error element, fault paths, run context, subflows and invocable actions (including flows used as Agentforce agent actions), Flow Tests, and migrating Workflow Rules and Process Builder.

Design Salesforce data models for Spring '26 — standard vs custom objects, lookup vs master-detail vs junction, record types, field design, config data in Custom Metadata vs Custom Settings, external Ids, formulas and roll-ups, the sharing design (OWD, role hierarchy, sharing rules, Apex sharing, restriction rules, Experience Cloud licences), data classification, large data volumes with skinny tables, indexes, skew and Big Object archiving, the Data 360 boundary, and ERD/data-dictionary deliverables.

Choose and structure the UI layer of a Salesforce solution for Spring '26 — the build-vs-configure ladder from Dynamic Forms and screen flows to LWC, Agentforce surfaces, Experience Cloud LWR sites, Lightning Out 2.0 and off-platform apps; org-wide design-system strategy; codebase and package layout; packaging with unlocked, org-dependent and 2GP managed packages; multi-org component sharing; Aura and Visualforce migration plans; and the ADR that records the decision.

Design and build Salesforce integrations for Spring '26 — the canonical patterns, inbound REST/Composite/Bulk API 2.0 and Apex REST, outbound callouts through Named and External Credentials, HTTP Callout actions in Flow, Platform Events, Change Data Capture, Pub/Sub API with managed subscriptions, Event Relay, Salesforce Connect, External Client Apps and OAuth flows, API limits, idempotency and retries.

Design and write Salesforce Apex tests for Spring '26 — the `Assert` class, TestDataFactory and builders, `@TestSetup`, `System.runAs`, the Stub API vs a mocking library, `HttpCalloutMock`, `Test.getEventBus().deliver()`, Queueable/Finalizer/Batch/Cursor tests, `@AuraEnabled` and `@InvocableMethod` controller tests, flow tests with `sf flow run test` and the unified `sf logic run test`, and coverage gates.

Test the Salesforce UI for Spring '26 — LWC unit tests with `@salesforce/sfdx-lwc-jest`, mocking wired Apex with `createApexTestWireAdapter` and LDS adapters with `emit`, mocking `lightning/navigation`, `lightning/messageService`, `lightning/modal` and toasts, accessibility assertions with sa11y, Flow-screen component tests alongside `sf flow run test`, and browser journeys with Playwright or UTAM including Experience Cloud guest users.

Reviews Salesforce changes and delivers severity-ranked findings with concrete fixes and a merge verdict — Apex bulkification and governor limits, sharing and CRUD/FLS enforcement, SOQL and DML in loops, trigger framework and automation ordering, Flow bulk safety and fault paths, Lightning Web Component patterns under Lightning Web Security, SLDS 2 styling, test quality beyond coverage percentage, and package and metadata hygiene.

Set up and run Salesforce delivery for Spring '26 — SFDX project layout and `sfdx-project.json`, scratch orgs vs sandboxes and source tracking, the `sf` CLI (`project deploy validate` then `deploy quick`, `retrieve start`, `org create scratch`), branching and release flow, DevOps Center vs Gearset/Copado vs a GitHub Actions pipeline you own, unlocked and 2GP package promotion, quality gates with Code Analyzer v5 and `code-analyzer.yml`, Apex and Flow test levels, deploying flows as active, destructive changes, environment variables and secrets, Sandbox Preview testing and rollback.

Designs and hardens security on the Salesforce Platform — enforcing sharing and field-level security in Apex with USER_MODE, stripInaccessible and `with sharing`, guest user and Experience Cloud site hardening, org posture through Health Check, MFA and session settings, Shield Platform Encryption and Event Monitoring, Trusted URLs and CSP for Lightning Web Security, named credentials over stored secrets, and the Code Analyzer v5 security engines in CI.

Always-on rules for writing Salesforce Apex classes, triggers, async jobs and test classes.

Always-on rules for writing Salesforce Lightning Web Components, their templates, styles, metadata and Jest tests.