Frontend Engineering
Implement maintainable, accessible, responsive, and observable frontend experiences that match approved product/design intent while integrating safely with application state and backend contracts.
A focused method your agent applies to a specific problem or piece of work.
Ask your connected agent for an outcome. It finds relevant methods and business context.
- What you get
- What to bring
- product and feature requirements
- approved UI/UX or design-system guidance
- project-local frontend architecture and coding rules
- backend/API contracts and authentication model
- browser/device support requirements
- accessibility, performance, SEO, analytics, and privacy constraints
- localization and content requirements
- deployment and monitoring constraints
How it works 3 steps
A typical way this skill turns context into a useful result. The exact choices depend on your task.
- 01
Frame the task Input Your goal and relevant context→Output A focused starting point
- 02
Apply the skill Input The focused starting point→Output A draft or recommendation
- 03
Review and refine Input The draft or recommendation→Output A result ready to use
↶ Review, learn, and revisit an earlier step when needed.
Decision rules
- Match the existing framework and architecture unless a change is explicitly justified by project requirements. - Do not create a shared component merely because two pieces of markup look similar; share when behavior, semantics, and change ownership are meaningfully common. - Do not introduce global state, client-side caching, virtualization, service workers, micro-frontends, or other complexity without a demonstrated need. - Prefer semantic HTML and native controls before custom widgets. - Do not use ARIA to compensate for avoidable non-semantic markup. - Treat design fidelity as one requirement among usability, accessibility, maintainability, and performance. - Performance optimizations require a known bottleneck or a clear high-cost pattern; do not cargo-cult memoization, lazy loading, or code splitting. - Avoid optimistic UI when rollback, conflict, or user confusion would be unsafe. - Preserve server/backend authorization as authoritative; frontend permission checks are user-experience controls, not security boundaries. - Handle unexpected or incomplete API data defensively at system boundaries. - Progressive enhancement and graceful degradation are preferred when they materially improve reliability for the supported user base.
Guardrails
- Match the existing framework and architecture unless a change is explicitly justified by project requirements. - Do not create a shared component merely because two pieces of markup look similar; share when behavior, semantics, and change ownership are meaningfully common. - Do not introduce global state, client-side caching, virtualization, service workers, micro-frontends, or other complexity without a demonstrated need. - Prefer semantic HTML and native controls before custom widgets. - Do not use ARIA to compensate for avoidable non-semantic markup. - Treat design fidelity as one requirement among usability, accessibility, maintainability, and performance. - Performance optimizations require a known bottleneck or a clear high-cost pattern; do not cargo-cult memoization, lazy loading, or code splitting. - Avoid optimistic UI when rollback, conflict, or user confusion would be unsafe. - Preserve server/backend authorization as authoritative; frontend permission checks are user-experience controls, not security boundaries. - Handle unexpected or incomplete API data defensively at system boundaries. - Progressive enhancement and graceful degradation are preferred when they materially improve reliability for the supported user base.
Example outcome request
Describe the result you need and add your team's context. Your connected agent finds the methods that fit.
I want this outcome: Implement maintainable, accessible, responsive, and observable frontend experiences that match approved product/design intent while integrating safely with application state and backend contracts.
Use my team's shared skills, workflows, and business context through Popasoda to find the relevant methods. Consider Frontend Engineering (frontend-engineering) if it fits the goal. Ask for missing context before starting, and follow the chosen methods' review gates and guardrails.
Relevant guardrails for this method: - Match the existing framework and architecture unless a change is explicitly justified by project requirements. - Do not create a shared component merely because two pieces of markup look similar; share when behavior, semantics, and change ownership are meaningfully common. - Do not introduce global state, client-side caching, virtualization, service workers, micro-frontends, or other complexity without a demonstrated need. - Prefer semantic HTML and native controls before custom widgets. - Do not use ARIA to compensate for avoidable non-semantic markup. - Treat design fidelity as one requirement among usability, accessibility, maintainability, and performance. - Performance optimizations require a known bottleneck or a clear high-cost pattern; do not cargo-cult memoization, lazy loading, or code splitting. - Avoid optimistic UI when rollback, conflict, or user confusion would be unsafe. - Preserve server/backend authorization as authoritative; frontend permission checks are user-experience controls, not security boundaries. - Handle unexpected or incomplete API data defensively at system boundaries. - Progressive enhancement and graceful degradation are preferred when they materially improve reliability for the supported user base.