erol

Plugin erol from marketplace erol in erolemir/EROL. Commands read from the repo's manifest — 1 month ago.

Skills (97)

• accessibility-audit

  Improve interactive UI access through keyboard, semantics, focus, and perceivable feedback.

• analytics-event-contracts

  Define analytics events with stable identities, semantics and privacy-aware verification.

• api-contract-design

  Evolve service contracts with compatibility, validation, and failure semantics.

• architecture-decision

  Make bounded architectural decisions backed by repository constraints and explicit tradeoffs.

• authentication-session-security

  Review login, tokens and session lifecycle for binding, expiry, revocation and recovery weaknesses.

• authorized-security-testing

  Plan and execute bounded security tests on explicitly authorized targets with reproducible findings.

• background-job-reliability

  Make queued work recoverable through acknowledgements, leases, bounded retries and safe replay.

• brand-positioning

  Develop positioning from customer alternatives, credible differentiation and proof.

• caching-strategy

  Design cache keys, invalidation and freshness policies from measured read behavior and correctness requirements.

• ci-failure-triage

  Diagnose build and CI failures through reproducible environment comparisons.

• cloud-cost-optimization

  Reduce cloud spend using attributable usage, unit costs and reversible capacity decisions.

• configuration-management

  Make configuration explicit, validated and environment-consistent without exposing secrets.

• container-runtime-hardening

  Reduce container privileges and image exposure while preserving required runtime behavior.

• content-distribution-plan

  Plan reusable content and channel distribution around audience needs, capacity and measurable outcomes.

• context-handoff

  Prepare bounded task and agent handoffs with evidence and explicit unresolved work.

• conversion-funnel-analysis

  Analyze conversion funnels with consistent identities, event ordering and meaningful denominators.

• customer-discovery

  Plan unbiased customer discovery that separates observed problems from reactions to a proposed solution.

• customer-segmentation

  Define actionable customer segments from needs, behavior and reachable evidence rather than invented personas.

• dashboard-design

  Design operational dashboards around decisions, metric definitions and comparable data states.

• data-pipeline-integrity

  Build batch or streaming pipelines with explicit schemas, reconciliation and recoverable checkpoints.

• database-backup-restore

  Design backup and restore procedures around recoverable data, dependencies and measured recovery objectives.

• database-migration-safety

  Prepare compatible schema changes with recovery and data-integrity verification.

• database-query-performance

  Measure and improve slow SQL through query plans and representative workload evidence.

• dependency-boundaries

  Restructure modules around dependency direction, ownership and testable interfaces.

• dependency-supply-chain-review

  Review dependency provenance, build scripts and artifact integrity for supply-chain exposure.

• dependency-upgrade

  Upgrade dependencies through compatibility research, reproducible resolution, and rollback evidence.

• design-system-components

  Create reusable UI components with explicit variants, interaction contracts and consistent tokens.

• disaster-recovery

  Plan disaster recovery across infrastructure, data, credentials and routing with a tested failback boundary.

• distributed-workflow

  Coordinate multi-service effects using durable states, reconciliation and explicit compensation limits.

• documentation-maintenance

  Update project documentation from observed behavior and reproducible examples.

• error-handling-contracts

  Design errors that preserve causality, stable caller behavior and safe operational diagnostics.

• evidence-code-review

  Review changes for concrete correctness risks with reproducible findings.

• experiment-statistics

  Evaluate experiments with valid randomization, uncertainty and predeclared outcome decisions.

• file-upload-pipeline

  Build resumable file ingestion with bounded resources, durable ownership and visible processing states.

• form-validation

  Implement form validation, submission and recovery without losing user input or trusting client checks alone.

• frontend-data-fetching

  Manage remote UI data through cache keys, cancellation and consistent loading/error states.

• frontend-e2e-testing

  Test critical browser journeys with stable state setup, meaningful assertions and controlled dependencies.

• frontend-state-correctness

  Diagnose stale UI, asynchronous races, and inconsistent client state transitions.

• git-branch-integration

  Synchronize and integrate Git branches while preserving local work and divergent history.

• growth-experiment-design

  Design bounded business growth experiments with falsifiable hypotheses, guardrails and decision rules.

• incident-debugging

  Investigate reproducible failures and preserve verified causes and regression evidence.

• infrastructure-change-plan

  Review infrastructure changes for drift, state ownership, blast radius and recoverable application impact.

• internationalization

  Implement locale-aware UI strings, formats and directionality without changing canonical stored values.

• kubernetes-rollout

  Plan recoverable Kubernetes deployments using readiness, capacity, versioned artifacts and rollback checks.

• landing-page-optimization

  Improve landing pages through message/offer alignment, user friction and measured conversion hypotheses.

• learning-pattern-discovery

  Turn repeated verified incidents into bounded project workflow candidates.

• legacy-modernization

  Modernize legacy code incrementally with characterization, compatibility seams and recoverable rollout.

• lifecycle-email-marketing

  Design permission-aware lifecycle emails triggered by meaningful product states and measured user outcomes.

• linux-service-operations

  Diagnose Linux service health from process ownership, logs, resources and configuration before changing service state.

• llm-feature-evaluation

  Evaluate LLM features on representative fixtures, failure categories, cost and human-review requirements.

• market-research

  Research a market and competitors with dated evidence, explicit segments and defensible comparisons.

• marketing-copywriting

  Write truthful campaign or product copy matched to audience intent, channel constraints and a clear action.

• memory-hygiene

  Preserve small, evidence-backed project memory with redaction, staleness, and provenance.

• message-idempotency

  Prevent duplicate side effects in retried requests and at-least-once message consumers.

• multi-tenant-isolation

  Verify tenant scoping across queries, jobs, caches and object references.

• observability-design

  Design logs, metrics and traces that explain user-visible failures without excessive cardinality or sensitive payloads.

• paid-search-campaign

  Design paid-search campaign drafts with intent separation, budget boundaries and reliable conversion measurement.

• paid-social-campaign

  Prepare paid-social creative tests with credible messages, audience boundaries and budget-aware measurement.

• partnership-strategy

  Evaluate partnerships from mutual customer value, economics, responsibilities and pilot evidence.

• performance-profiling

  Measure bottlenecks before optimizing CPU, memory, or end-to-end latency.

• pricing-packaging-research

  Research product pricing and packaging from customer value, unit economics and defensible willingness-to-pay evidence.

• privacy-data-retention

  Map sensitive data collection, retention and deletion to concrete systems and stated policy requirements.

• product-prioritization

  Prioritize product work using customer evidence, constraints and transparent impact assumptions.

• production-incident-response

  Respond to production incidents with evidence preservation, scoped mitigation and recovery verification.

• rate-limit-design

  Design bounded request quotas with explicit identities, burst behavior and fair failure responses.

• realtime-service

  Design authenticated realtime connections with bounded delivery, reconnect and backpressure behavior.

• regression-test-design

  Select focused tests that demonstrate behavioral changes and protect meaningful boundaries.

• release-verification

  Prepare evidence-backed releases with explicit readiness gates and recoverable rollout.

• repository-change-planning

  Plan a scoped code change from affected callers, compatibility constraints and verifiable milestones.

• repository-exploration

  Find relevant code paths and project conventions before planning a change.

• requirements-acceptance

  Turn feature requests into observable acceptance criteria, boundaries and unresolved decisions.

• responsive-layout

  Build layouts that remain usable across viewport sizes, zoom and variable content.

• retention-cohort-analysis

  Measure retention using comparable cohorts, meaningful activity definitions and censoring-aware windows.

• reverse-proxy-tls

  Configure proxy routing and TLS while preserving trusted client identity and upstream request semantics.

• safe-refactoring

  Change structure while preserving externally observable behavior and project style.

• sales-pipeline-design

  Design a sales pipeline around buyer evidence, stage exit criteria and reliable operational reporting.

• secrets-rotation

  Plan and verify credential rotation with overlap, revocation and recoverable dependent-service updates.

• secure-file-handling

  Review untrusted file parsing, paths and storage boundaries for traversal and resource exhaustion.

• security-boundary-review

  Examine untrusted inputs, authorization boundaries, secret handling, and dangerous side effects.

• security-log-detection

  Design actionable security detections from reliable event semantics and tested false-positive controls.

• seo-content-brief
• seo-international-sites
• seo-migration
• seo-performance-measurement
• seo-structured-data
• seo-technical-audit
• service-api-integration
• skill-quality-evaluation
• stable-pagination
• test-fixture-design
• threat-modeling
• tool-capability-selection
• transaction-boundaries
• vulnerability-triage
• web-performance-budget
• webhook-delivery
• erol

Similar plugins