Org Skills

Write production-grade Adobe Experience Manager back-end Java for AEM as a Cloud Service (with 6.5 notes) — OSGi Declarative Services, runmode configs, Sling servlets and filters, service users, queries and Oak indexes, jobs, schedulers, workflows and replication.

Build and review Adobe Experience Manager Sites components (AEM as a Cloud Service first, 6.5 noted) — HTL templates with correct XSS contexts, Sling Models and exporters, Core Components proxies and delegation, Granite UI dialogs, editable templates, policies and the Style System.

Build and review sites on AEM Edge Delivery Services (aem.live, formerly Franklin/Helix) — boilerplate project setup, content sources, blocks, loading phases, spreadsheets/JSON, preview/live and the Sidekick, with a 100 Lighthouse score as the bar.

Build and review Adobe Experience Manager Sites front-end code (AEM as a Cloud Service first, 6.5 noted) — the archetype ui.frontend webpack build, client libraries, Style System CSS, responsive grid, author-safe JavaScript, the Cloud Manager front-end pipeline, Site Themes and performance.

Design and build headless content delivery on AEM as a Cloud Service — Content Fragment Models, GraphQL persisted queries, CDN caching, CORS/dispatcher, auth and front-end consumers.

Designs and reviews Adobe Experience Manager solution architecture — AEM as a Cloud Service vs 6.5 trade-offs, delivery model (HTL Sites, headless Content Fragments + GraphQL, hybrid, Edge Delivery Services), Maven archetype modules, repository structure, MSM and translation, templates and policies, assets, integrations, caching, security, environments and sizing.

Writes, reviews and debugs AEM Dispatcher and CDN configuration — flexible-mode file layout, deny-by-default filters, cache rules, statfileslevel and invalidation, TTLs, rewrites and redirects, headers and CORS, and Cloud Service CDN rules for traffic filtering and WAF.

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

Design and write tests for Adobe Experience Manager projects — JUnit 5 unit tests with AEM Mocks for Sling Models, servlets and OSGi services, integration tests with AEM testing clients, UI tests, front-end Jest tests, and Cloud Manager quality gates.

Review AEM code changes (pull requests, diffs, packages) with a severity-ranked checklist covering security, resource handling, performance, Sling Models, OSGi services, components and dialogs, Cloud Service compatibility, content package filters, dispatcher/CDN rules, tests and accessibility.

Design CI/CD, environments and release flow for AEM as a Cloud Service with Cloud Manager — pipeline types, quality gates, Maven build rules, Git setup, env vars and secrets, RDEs, local SDK, logs, repoinit and index deployment.

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

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 modern .NET — minimal APIs vs controllers, DI lifetimes, options and secrets, correct async/await with cancellation, nullable reference types, validation, ProblemDetails errors, EF Core usage, HttpClientFactory with resilience, structured logging, JWT and policy auth, background services and OpenAPI.

Architect-level guidance for structuring .NET back-end systems — modular monolith first, vertical slices vs clean/onion layering, project and assembly boundaries, pragmatic domain modelling, CQRS and MediatR trade-offs, messaging with the outbox pattern and idempotency, data ownership, API versioning, cross-cutting concerns, per-environment configuration, OpenTelemetry, local orchestration and container deployment, captured as ADRs.

Diagnose and fix .NET and ASP.NET Core performance problems — measure first with BenchmarkDotNet, dotnet-counters, dotnet-trace, dotnet-dump and APM/OpenTelemetry, then reduce allocations, fix thread pool starvation and sync-over-async, tune EF Core queries, add caching and output caching, choose GC modes, and weigh Native AOT and ReadyToRun.

Design and write a .NET test strategy and the tests themselves — xUnit (or NUnit/MSTest) conventions, unit tests of domain logic, ASP.NET Core integration tests with WebApplicationFactory, real databases with Testcontainers, mocking with NSubstitute or Moq and when not to mock, test data builders, assertion libraries, contract and architecture tests, coverage with coverlet, 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 (Express, Fastify, NestJS, Hono), strict tsconfig and ESM, schema validation at the edge, central error handling, validated config, data access and transactions, resilient outbound HTTP, auth, pino logging, graceful shutdown, background jobs and security basics.

Design and review the architecture of Node.js/TypeScript back-end systems — modular monolith and feature modules, ports-and-adapters, NestJS modules vs Fastify plugins, dependency injection, domain vs transport separation, monorepos and shared packages, event-driven messaging with outbox and idempotency, API style choice, versioning, multi-tenancy, OpenTelemetry and deployment trade-offs.

Diagnose and fix Node.js back-end performance problems — event loop blocking and lag, high latency and low throughput, CPU hot paths, memory leaks and OOM kills, stream backpressure, JSON serialization cost, slow queries and pool exhaustion, caching, HTTP keep-alive and scaling in containers.

Design a test strategy for Node.js/TypeScript back-end services and write the tests — runner choice (Vitest, Jest, node:test), unit vs integration vs end-to-end balance, in-process HTTP tests with supertest or Fastify inject, real databases with Testcontainers, outbound HTTP mocking with MSW or nock, fake timers, database isolation, contract tests with Pact, factories, coverage and flaky async tests in CI.

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

Design and review HTTP/REST APIs in any back-end stack — resource modelling and naming, methods and status codes, RFC 9457 Problem Details errors, cursor vs offset pagination, filtering and sorting, idempotency keys, ETag/If-Match concurrency, versioning and backward compatibility, long-running operations, webhooks, rate limiting, OAuth2 scopes, and an OpenAPI-first workflow with Spectral linting.

Perform a staff-engineer-level code review of back-end changes in any stack (.NET, Java/Spring, Node.js/TypeScript, Python, Go) covering correctness, concurrency, transactions, security, data migrations, API contracts, resilience, performance, observability, tests and rollout safety, and deliver a severity-ranked findings table with concrete fixes and a merge verdict.

Write production-quality modern Angular (v17+) code day to day — standalone components with signal inputs/outputs, computed and effect done right, templates with @if/@for/@switch/@defer, typed reactive forms, HttpClient services with interceptors, RxJS-to-signal conversion, dependency injection with inject(), routing with lazy routes and input binding, directives and pipes, Angular Material/CDK usage, styling and accessibility.

Architect-level guidance for modern Angular (v17+) applications — standalone components, signals-based state, feature-sliced folder structure, dependency injection design, routing with lazy loading, RxJS boundaries, Nx monorepos, and migrating legacy NgModule/zone.js codebases.

Diagnose and fix Angular performance — slow change detection, ExpressionChangedAfterItHasBeenChecked, big bundles, slow initial load, janky lists/tables, memory leaks from subscriptions, and poor Core Web Vitals.

Design and write tests for Angular applications — unit tests with Vitest or Jest, component tests with TestBed and Angular Testing Library, HttpTestingController, testing signals, SignalStore/NgRx, pipes, directives, guards, interceptors, and end-to-end tests with Playwright; plus migrating off Karma/Jasmine.

Always-on rules for writing modern Angular components, services, directives, pipes and routes.

Write production-quality React code day to day — components, hooks, props and TypeScript typing, forms, data fetching with TanStack Query or Server Components, effects done right, styling, accessibility, error and loading states, and idiomatic React 19 features (actions, use, ref as prop, React Compiler).

Architect-level guidance for structuring React applications — folder layout, component composition, state management selection, data fetching, routing, TypeScript conventions, and scaling a codebase to many teams.

Diagnose and fix React performance problems — slow renders, re-render storms, large bundles, poor Core Web Vitals (LCP, INP, CLS), memory leaks, and janky lists.

Design and write a React test strategy and the tests themselves — unit tests with Vitest/Jest and React Testing Library, API mocking with MSW, hook testing, component visual/interaction tests in Storybook, and end-to-end tests with Playwright.

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

Write production-quality React Native / Expo code day to day — screens, components, styling with StyleSheet/NativeWind and theme tokens, safe areas and keyboard handling, lists, navigation with Expo Router, forms, images, permissions and Expo SDK modules, platform differences, accessibility, offline and error states, and gestures/animations with Reanimated.

Architect-level guidance for React Native apps — Expo vs bare workflow, New Architecture (Fabric/TurboModules), navigation (Expo Router / React Navigation), state and offline-first data, native module strategy, monorepo sharing with web, theming, and release engineering with EAS.

Diagnose and fix React Native performance — slow app startup, dropped frames, janky FlatList/FlashList scrolling, laggy animations and gestures, JS thread blocking, large bundles, memory leaks, and image loading.

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

Perform a staff-engineer-level code review of frontend changes in any stack (React, React Native, Angular, Salesforce LWC, plain TypeScript) — correctness, architecture boundaries, accessibility, performance, security, testing, and maintainability — and deliver findings ordered by severity with concrete fixes.

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

Turns a feature idea, PRD, meeting notes or bug report into well-formed Azure DevOps Features, User Stories and Tasks, and creates them only after you confirm.

Reviews the current branch's changes or an Azure DevOps pull request and returns severity-ranked findings with concrete fixes and a merge verdict.

Produces user-facing release notes and an internal risk and rollout section for a tag, branch, date range or Azure DevOps pipeline run.

Performs a focused security review of changes or a code area against OWASP Top 10 and API Security Top 10, with evidence, exploit scenarios and fixes.

Writes or improves tests for the code you point at or your current changes, runs them until green, and maps coverage to acceptance criteria.

Always-on, stack-agnostic security rules for every file in the repository.

Connects GitHub Copilot to Azure DevOps through Microsoft's hosted Azure DevOps MCP server, so agents can read work items, pull requests, pipelines and builds, wiki pages and test plans.

Write production-grade Salesforce Apex — bulkified triggers with a trigger framework, service/selector/domain layering, SOQL and DML best practices, governor-limit-aware design, sharing and security (with sharing, USER_MODE, FLS), asynchronous Apex (Queueable, Batch, Schedulable, Platform Events, future), error handling and logging, and Apex test classes that assert behaviour.

Build production-grade Salesforce Lightning Web Components (LWC) — component design, @wire vs imperative Apex, Lightning Data Service (LDS) and UI API, Lightning Message Service, events and composition, SLDS 2 styling and Lightning Base Components, Experience Cloud (LWR) sites, LWC in Flow screens, governor-limit-aware UI patterns, and security (CRUD/FLS, Locker/Lightning Web Security).

Design, build and review Salesforce automation — choosing between Flow (record-triggered, scheduled, screen, autolaunched, platform-event-triggered), Apex triggers, and Approval Processes/Orchestrator; before-save vs after-save flows, entry criteria, bulk-safe flow patterns, subflows and invocable actions, error handling and fault paths, flow testing, governance for one-automation-per-object, and migrating Workflow Rules and Process Builder to Flow.

Design and review Salesforce data models — standard vs custom objects, lookup vs master-detail vs junction objects, record types, field design and picklists vs lookups, external Ids, formula and roll-up strategy, sharing model (OWD, roles, sharing rules, Apex/manual sharing, restriction rules), large data volume (LDV) patterns including skinny tables, indexes, skew and archiving, Big Objects, Data Cloud boundaries, and migration/ERD deliverables.

Architect-level guidance for Salesforce UI solutions — choosing between declarative (Flow, Dynamic Forms, App Builder), LWC, Experience Cloud (LWR vs Aura), Lightning Out / LWC on external sites, and off-platform apps (React/Angular) talking to Salesforce via API; org-wide component library and design system strategy; performance and governor-limit-aware UI data patterns; state management across LWCs; packaging (unlocked/2GP), DevOps, and Aura-to-LWC migration.

Design and implement integrations to and from Salesforce — choosing patterns (request-reply, fire-and-forget, batch sync, event-driven, data virtualisation, UI mashup), inbound APIs (REST, SOAP, Composite, GraphQL, Bulk API 2.0, custom Apex REST), outbound callouts with Named Credentials and External Services, Platform Events and Change Data Capture, Pub/Sub API, Salesforce Connect, MuleSoft/middleware boundaries, authentication (OAuth flows, JWT, External Client Apps, Connected Apps), API limits, idempotency, error handling and retries, and integration testing.

Test Salesforce UI end to end — LWC unit tests with Jest (@salesforce/sfdx-lwc-jest), mocking @wire adapters, Apex, LDS, and Lightning Message Service, accessibility checks with sa11y, Apex test classes written for @AuraEnabled controllers (positive, negative, bulk, sharing), and browser/E2E testing of Lightning pages and Experience Cloud with UTAM or Playwright.

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.