satishTheLegend

UniversalDesigner is the single entry point for ALL frontend design, animation, and 3D work. It understands the project architecture (stack, existing design infra, constraints), sets a design direction, then routes execution to the right specialist skill(s) among 24 design skills: 3D engines (Three.js, R3F, Babylon, PlayCanvas, A-Frame), scroll/motion libraries (GSAP/ScrollTrigger, Locomotive, Barba, AOS, Framer Motion, React Spring, Anime.js), component/asset libraries (Magic UI/React Bits, Lottie, Rive, PixiJS), authoring pipelines (Blender, Spline, Substance), and the design-system/taste layer (modern-web-design, ui-ux-pro-max, frontend-design). Use it whenever a task involves building, designing, redesigning, reviewing, fixing, or animating any UI/UX, web page, landing page, dashboard, component, hero, scroll experience, page transition, 3D scene, product viewer, data-viz, micro-interaction, or visual effect, on web or Flutter. It invokes specialists via the Skill tool.

Turns any raw or incomplete product idea into a deeply researched, gap-free, implementation-ready programme — preserves the original idea, auto-fills a product brief, runs deep research with evidence/confidence ratings, defines the full architecture, splits it into dependency-ordered phases, and produces ready-to-paste designer (Stage 1) and engineering (Stage 2) prompts with requirement traceability and security, privacy, and accessibility auditing. Use whenever the user shares a product, app, SaaS, platform, or marketplace idea — even one line like "I want to build X" or "here's my startup idea"; wants to plan, scope, research, or validate a product; wants work split into phases; wants a screen inventory, workflow map, or design system; wants design-before-code prompts; or wants to audit or continue a plan for missing requirements, contradictions, or security/privacy/accessibility gaps. Trigger even without the word "plan" — e.g. "turn this into a real product" or "what should I build first".

Transforms any informal, vague, or incomplete product idea into a deeply researched, gap-free, implementation-ready programme — deep research, full product architecture, dependency-ordered phases, complete UI/UX and design-system architecture, and ready-to-paste designer and engineering prompts, with end-to-end requirement traceability and continuous security, privacy, and accessibility auditing. Use whenever the user shares a product, app, SaaS, platform, or marketplace idea; wants to plan, scope, research, or validate a product; wants work split into phases; wants a complete screen inventory, workflow map, or design system; wants design-before-implementation prompts; wants to audit a plan for missing requirements, contradictions, or gaps; or wants to verify or continue a previously planned product. Trigger even when the user gives only a one-line idea or does not say 'plan' explicitly — e.g. 'I want to build X', 'here is my startup idea', 'turn this into a real product', or 'what should I build first'.

Builds and maintains a solo operator's security risk program as three durable, machine-checkable artifacts: a living risk register (likelihood x impact, owner, treatment, review date), a NIST CSF 2.0 self-assessment scorecard (Govern/Identify/Protect/Detect/Respond/Recover at maturity tiers), and a lightweight NIST-endorsed incident-response plan (severity tiers, escalation tree, per-scenario runbooks, notification clock). Scans the repo, IaC, and dependency manifests to seed an asset inventory, scores risks deterministically, and on re-run diffs prior artifacts to surface drift and FORCE re-acceptance of overdue risks. Use whenever the user touches their own security, risk, or compliance posture even if they don't explicitly ask: when they mention a risk register, threat or exposure, "are we SOC2-ish / secure enough", a data breach or leaked secret, an incident or 2am outage plan, NIST CSF / ISO 27001, audit prep, or "what could go wrong with this system". Also use on any periodic security review or when a p

Runs one phased go/no-go Production Readiness Review (PRR) gate against a feature or service right before it ships. Scopes the change and blast radius, picks a gate profile (internal tool / public service / paid-or-LLM-backed), then walks five dimension checklists — reliability, security, operability, cost, observability — tuned to the actual detected stack. Runs deterministic static probes over the repo and IaC (committed secrets, exposed/unauthed endpoints, missing healthchecks, irreversible migrations, unbounded-cost paths, missing rollback) so findings are grounded in code, not optimism. Scores each check pass / fail / N-A / risk-accepted, splits launch-blocking from advisory by profile, and emits a dated PRR record with a GO / NO-GO / GO-WITH-RISKS verdict, an owned remediation list, and a risk-acceptance log the next launch diffs. Use whenever the user is about to ship, deploy, launch, release, "go live", cut a release, flip a feature flag to prod, or merge a change touching users, data, money, or an ex

Runs NIST AI RMF (Govern, Map, Measure, Manage) for a solo or small-team builder shipping an LLM/ML feature, turning "it seemed fine in the demo" into a living AI-RMF profile plus a runnable offline eval gate: named failure modes, chosen metrics with acceptable limits AND course-correction triggers, an explicit list of risks deliberately NOT measured and why, and signed-off residual risk. Use whenever the user is building, shipping, reviewing, or changing anything that calls an LLM or ML model — a chatbot, RAG pipeline, agent, classifier, summarizer, extraction step, prompt, or judge — EVEN IF they don't explicitly ask for governance, evals, or risk management. Use proactively when the user says they will "ship", "deploy", "it works", "good enough", or shows a model/prompt with no evals; when they SWAP a model, edit a prompt, or add a use case (re-open Map/Measure); when they mention hallucination, prompt injection, jailbreak, bias, PII/data leakage, over-reliance, cost blowup, or quality regression; or when

Acts as a principal/staff engineer architecture review board for a solo or small-team operator: reverse-engineers a C4 model of the codebase, forces Architecture Decision Records (with >=2 real alternatives + consequences), runs an adversarial reviewer that pressure-tests designs, and — the core — derives evolutionary-architecture FITNESS FUNCTIONS and wires them into CI so layering/coupling/cycle/size drift is caught mechanically forever. Maintains an append-only decision ledger as the system-of-record for "why we built it this way." Use whenever the user adds a new dependency, datastore, service boundary, protocol, or framework; designs/refactors a module or system; writes or edits an ADR/RFC/design doc; sets up or fixes CI architecture checks; or asks "is this a good design?", "what are the tradeoffs?", "will this scale?", "review my architecture", or "has the architecture drifted?" — even if they don't explicitly ask for an architecture review. Also use proactively before merging a structurally significan

Compresses the staff/principal-engineer planning function — turning a fuzzy initiative into a written RFC/design doc, Architecture Decision Records (ADRs), three-point effort estimates, a weighted trade-off matrix, a likelihood×impact risk register, and a phased rollout/backout plan, plus a stakeholder-ready one-pager — BEFORE any code is written. Runs a gate-sequenced lifecycle (triage → framing → options → trade-off → ADRs → estimation → risk → rollout) where deterministic scripts block advancing past gaps. Use whenever the user is starting, scoping, planning, architecting, or estimating a new project, feature, migration, refactor, or initiative — even if they don't explicitly ask for a "plan" or "RFC"; especially when they say "how should I approach X", "should I use A or B", "how long will X take", or "what could go wrong with X". Also use when they want a design doc, ADR, effort estimate, trade-off analysis, risk register, rollout plan, or an exec one-pager. Right-sizes the artifact set (micro/standard/h

Runs a complete, framework-driven threat-modeling engagement against any system the user describes or that lives in the current repo. Inventories assets and data classifications, reconstructs a data-flow diagram with trust boundaries, enumerates threats per element with STRIDE (plus LINDDUN for personal-data flows), scores each deterministically with OWASP Risk Rating, designs concrete mitigations, runs a gap-analysis loop, and persists a versioned threat model plus a diffable remediation register (open/mitigated/accepted/transferred) tracking known risks to closure across sessions. Exports OWASP Threat Dragon JSON and a Markdown report. Use whenever the user designs, ships, reviews, or changes a feature with real attack surface — auth, sessions, payment/webhooks, file uploads, multi-tenant data, secrets/CI, LLM prompt-injection, public APIs — even if they never say "threat model": treat "is this secure?", "what could go wrong?", "did I miss anything?", or "before we launch" as triggers. Also use to revisit a

Maintains ONE canonical asset as the single source of truth and derives every channel deliverable — blog, newsletter, LinkedIn post, X/Twitter thread, short-video script, email — from it, with stable atom IDs, a provenance traceability matrix, a brand-voice and claim-consistency gate, and a propagate-on-change loop that flags exactly which outputs to regenerate when the source changes. Unlike one-shot repurposers, it keeps a content set coherent and updatable from one truth. Use whenever the user wants to repurpose, atomize, or distribute an article, blog post, talk, transcript, PR, doc, or thread across multiple channels; wants to turn one piece into blog + newsletter + LinkedIn + X + video script + email; wants their content kept consistent across platforms; says they updated the source and asks what else needs to change; wants a multi-channel content / distribution plan from one asset; or mentions a single source of truth for content. Use even if they do not explicitly ask — if the user shares one core pie

Stands up a rigorous, regression-proof evaluation harness for any LLM, agent, or RAG system from zero, through a dependency-ordered, phase-gated lifecycle: pins down what "good" means (dimensions, failure modes, thresholds, the decision the eval supports) BEFORE building; builds a versioned dataset with edge, adversarial, and known-failure cases plus a quarantined holdout split against overfitting; binds the right scorer per dimension (exact/regex/schema, embedding, code-exec, or LLM-as-judge), refusing a judge where a deterministic check works; calibrates the judge against human labels for measured agreement/bias; baselines with confidence intervals so deltas are real not noise; wires CI gates plus PR diff scorecards; and closes the loop with drift and prod feedback. Provider-agnostic; a runnable harness, not a checklist; composes with existing eval skills. Use whenever the user wants to build, set up, or fix evals for an LLM/agent/RAG system; has no way to tell if a change helped; wants an eval dataset, LLM

Turns a fuzzy talk idea into a tight, rehearsed, time-boxed talk — and owns the spoken-narrative + rehearsal layer that slide tools skip. Captures the brief (audience, venue, EXACT time budget, single takeaway, desired action); locks ONE through-line and a NAMED structure before any slides exist; sequences tension→resolution beats to the clock with minutes per beat; writes a spoken-language script with [pause]/[0:00] markers, callbacks and a signature line; designs the cold open and closing call-to-action; produces a per-beat SLIDE BRIEF (message titles + what each visual must do, no bullet dumps) and hands the actual deck to universal-designer; war-games hostile and gotcha Q&A with bridges and graceful "I don't know" answers; runs a rehearse-and-tighten loop where a timing engine measures the real script and FORCES specific cuts; and ships a day-of cue-card kit. Use whenever the user mentions a talk, keynote, conference or lightning talk, demo day, investor-pitch narrative, all-hands, webinar, or speech; wan