๐จFrontend Design
Production-grade interfaces with a clear visual point of view.
Production-grade interfaces with a clear visual point of view.
Attack your own AI features before users do.
Browser checks, screenshots, and interaction tests for local apps.
Stress-test autonomous agent behavior and tool use.
Map assets, trust boundaries, and abuse paths.
Design compact Telegram bot flows that do not spam chats.
Inspect code and config for accidental credentials exposure.
Create lightweight evals for prompts and AI features.
Current official references for OpenAI APIs and models.
Review pull requests for bugs, regressions, and missing tests.
Review login, sessions, redirects, and permission edges.
Framework-aware security review for JS, Python, and Go.
Find brittle props, layout drift, and duplicated UI patterns.
Find cramped layouts, clipped text, and broken mobile flows.
Test checkout paths, edge cases, and payment-state copy.
Compare UI screenshots and spot visual regressions.
Build a concise map of modules, flows, and ownership.
Generate focused browser tests for critical user paths.
Turn a rough vibe into a buildable product spec.
Prepare a product for launch-day traffic.
Publish Workers, Pages, and full-stack apps with clean defaults.
Turn vague bug reports into repeatable repro steps.
Add fast keyboard-first navigation to product UI.
Decide which agent tool should handle each task.
Practical accessibility checks for product UI.
Map roles, actions, and access edge cases.
Design durable prompts and agent instructions.
Turn repeatable agent workflows into reusable skills.
Create a staged, low-risk plan before touching code.
Wire external APIs with typed clients and clear error paths.
Plan framework, schema, or package migrations safely.
Spot risky files, missing checks, and unclear rollback before release.
Build useful fake APIs for frontend and demos.
Plan offline-first state and conflict handling.
Compact source-backed briefs for technical decisions.
Diagnose failing CI jobs and propose small fixes.
Tighten landing pages without turning them into templates.
Raise type safety without a noisy rewrite.
Create a release checklist for risky deploys.
Build reliable webhook handlers with verification and retries.
Plan and scaffold a practical browser extension.
Analyze competitor UX and positioning without fluff.
Find the files most worth cleaning up first.
Small, reliable API endpoints with validation and tests.
Write clear README sections, setup notes, and usage guides.
Review schema shape, indexes, migrations, and data risk.
Make failure paths explicit, useful, and testable.
Make interface copy shorter, clearer, and calmer.
Compare API shapes and flag breaking changes.
Find manipulative UX before it hurts trust.
Create an AI-readable map of your product docs.
Turn messy CSS into reusable design tokens.
Review dependencies for risk, overlap, and maintenance cost.
Design useful empty, loading, and no-results states.
Prepare UI for multiple languages without layout breakage.
Generate focused unit tests around edge cases.
Tight prompts, reusable briefs, and calmer agent instructions.
Review async jobs for retries, idempotency, and dead letters.
Set practical release gates from production risk.
Shape raw CSV or JSON into readable product-facing views.
Use browser signals to debug UI behavior and runtime errors.
Find tangled UI state and simplify data flow.
Map product events before adding tracking code.
Review cache keys, invalidation, TTLs, and stale data risk.
Set practical limits for bundle, images, and runtime cost.
Make plugin, app, or skill listings easier to trust.
Map how a product can earn repeat traffic.
Remove visual clutter and tighten spacing, labels, and states.
Design loading states that preserve layout and feel quiet.
Small repository chores handled with scripts and checks.
Check form validation, errors, and keyboard paths.
Turn product work into high-signal launch posts.
Create seed data that makes demos feel alive.
Review metadata, page structure, and crawl basics.
Check dialogs for focus, escape paths, and mobile fit.
Improve first-run product paths and setup guidance.
Clear README, changelog, and release notes without filler.
Turn noisy logs into useful operational signals.
Turn structured data models into usable UI plans.
Write tight product demo scripts from real UI.
Make a product demo crisp for investors or partners.
Turn commits or PRs into clean release notes.
Review flags, rollout states, and cleanup debt.
Make operational screens scannable without feeling cramped.
Design hints that help without annoying users.
Clean up image assets for size, format, and responsive use.
Draft a calm incident note and follow-up checklist.
Create realistic fixtures without brittle test setup.
Create reusable support replies and triage flows.
Review pricing page clarity, tiers, and conversion friction.
Find where setup docs fail a new user.
Draft plain privacy, terms, and disclaimer pages.
Review email, toast, and push copy for clarity.