Skill

Weave security through the whole lifecycle instead of bolting it on at the end, across: risk-based stance and principles (least privilege, defense in depth, fail secure, zero trust), threat model, secure design, input-distrusting code, CI security gates (SAST/DAST/SCA), the OWASP Top 10, and operations — tuned for a world where an agent writes insecure code by default, trusts its input, and ships a vulnerability green. The defensive half of the security pair (the shield); its adversarial counterpart is the `gungnir` skill (the spear). Use when the user wants a system secure-by-design, threat modeling, auth design, secrets management, to prevent injection / XSS / broken access control, set up scanning, meet compliance, or stand up security monitoring. Triggers on "is this secure", "threat model this", "secure coding", "OWASP", "least privilege", "manage secrets", "auth/authz design", "shift-left security / DevSecOps", "GDPR / PII / data classification", "security review".

Set up or harden a project's engineering process so quality has an automated floor instead of depending on anyone's discipline — version control & branching, code style, code review, CI/CD, and dependency/build management — tuned for a world where agents write much of the code and have no self-discipline to fall back on. Use when the user is bootstrapping or improving a team's workflow, choosing a branching strategy, setting up CI/CD or pre-commit hooks, defining a code-review process, enforcing lint/format, managing dependencies or reproducible builds, or fixing onboarding. Triggers on "set up CI", "git workflow / branching strategy", "how should we do code review", "add pre-commit hooks", "our builds aren't reproducible", "make this project team-ready".

Engineer a codebase's feedback surface so an agent gets clear feedback at every step — fast, local, attributed, deterministic, and hard to fake green — instead of flailing against late, opaque, or false-green signals. Set up the strict type layer, boundary validation, errors-as-values, structured failures, observability, and the gates that make the signal trustworthy. Use when the user wants a project to give the agent a "static-language / Rust-like hand-feel", asks to set up strict typing (pyright/mypy/tsc), add boundary validation (pydantic/zod), make failures legible, stop an agent guessing, or harden the feedback the codebase produces. Triggers on "clear feedback for the agent", "Rust-like hand-feel in Python/TS", "set up strict typing", "make failures legible", "the agent keeps flailing".

Plan, write, and harden tests with a risk-driven decision tree: choose what to test, the right test type, the right test double, and the cases that actually catch bugs. Use when the user wants to test code; asks what or how to test a function, module, API, or system; mentions unit, integration, end-to-end, property-based, contract, or characterization tests, edge cases, mocks or fakes, flaky tests, or coverage; or says things like "help me test this", "what should I test", "write tests for X", or "I just fixed a bug".

The state-architecture lens for a frontend build — the heart of the system. Use after keel's skeleton works, when designing or auditing state, or when "it's out of sync" bugs keep appearing. The one shift: almost all frontend complexity comes from state having MULTIPLE COPIES (DOM, server DB, URL, localStorage) drifting apart — so the craft is to relentlessly CLASSIFY each piece of state into the one bucket that owns it, minimize the source of truth and derive the rest, and model hard interactions as explicit machines. Triggers on "state management", "Redux / Zustand / Context / signals / Jotai", "where should this state live", "derived state / single source of truth", "this keeps getting out of sync", "useEffect to sync state", "prop drilling", "should this be in the URL", "a form's state", "too many boolean flags / loading and error flags". The data-flow shift: the component tree and the data-dependency graph are different shapes, and every state tool is a bypass channel for when they disagree.

The design-judgment spine of the atelier suite — where the visual language and archetype are chosen and the quantified targets all later lenses enforce are set. Use before any pixel is placed — before a color system or type scale is chosen. The one shift: good design is NOT defaults nudged until it "looks ok" — it is a few NON-DEFAULT, QUANTIFIED decisions: the point of view (derived from the product), the visual language that POV demands, the archetype, and what "premium" means in measurable terms. The agent, with no taste, defaults to the bland statistical mean of its training (e.g. warm-cream-editorial-serif), so these must be DECIDED and GATED. Triggers on "start a design / where to start visually", "which visual language / what style", "design brief / design direction". The spine to atelier as bearings is to surface: canon decides the direction the sibling lenses execute.

Attack your own system — under explicit authorization — to prove its defenses hold, before launch and continuously after: scope and authorize, recon, scan and enumerate, exploit and confirm real vulnerabilities (not scanner false positives), chain them into real impact, then report and re-test. The offensive half of the security pair (the spear) that proves what the `aegis` skill builds (the shield). Authorized, defensive penetration testing of systems you own or have written permission to test — never anything else. Use when the user wants to penetration-test their own application before launch, validate a fix actually closed a hole, stand up adversarial validation in CI or on a cadence, or learn to test for OWASP-class vulnerabilities on their own staging. Triggers on "pentest my app / attack my own system", "red-team my staging", "is this actually exploitable", "pre-launch security test".

Design a system's architecture for the agent-assisted era: choose the architecture style, the stack, the module boundaries, the contracts, and the data model — concentrating scarce human judgment on the irreversible decisions and letting agents move fast behind the reversible ones. Use when the user is designing or restructuring a system, choosing between monolith and microservices, picking a tech stack or database, defining APIs or module boundaries, deciding how to realize non-functional requirements (scale, availability, security), writing an ADR, or about to build something structurally non-trivial. Triggers on "design the architecture / system design", "monolith or microservices", "what stack should I use".

The method-design lens: turn a landed gap into a method worth writing up — for any field that runs experiments to publish (ML, optimization, operations research, systems). Use after prospect lands a gap, when designing a method and choosing among approaches, or stress-testing a method you already have. The one shift: a method is NOT nursed — it is RACED TO DEATH. Cheap agent prototypes let you race several variants in an elimination tournament against kill criteria written BEFORE the race (you fall in love with what you built), on a scaffold whose independent feasibility checker traps the agent's silent bugs (a variant that "soars" is usually infeasible); and you measure the ceiling FIRST. Triggers on "design a method / algorithm", "how should I approach this", "which variant is better", "is this method real or a bug".

The writing-submission-rebuttal lens: string the prior steps' argument into a manuscript, carry it to a venue, defend it through review, and climb the resubmission ladder — for any field that runs experiments to publish (ML, optimization, operations research, systems). Use when writing the paper, choosing a venue, drafting a rebuttal, or deciding where to resubmit. The one shift: if the prior discipline held, the paper ALREADY EXISTS IN PIECES — the prior claims, protocol, and probes are its argument, experiments, and discussion — so writing strings an existing argument into prose, not composing from scratch; the agent polishes and checks consistency, but the human keeps the story and signature, and every number must trace to a run id. Triggers on "write the paper / write up", "which venue / where should I submit", "write a rebuttal / respond to reviewers", "the paper got rejected / where to resubmit".

The experiment-design lens: turn the surviving method into a protocol that produces evidence a reviewer believes — for any field that runs experiments to publish (ML, optimization, operations research, systems). Use after crucible lands a method, when planning the experiments, or stress-testing a plan. The one shift: you write down what counts as EVIDENCE before you look at the data — the protocol (claims, instances, baselines, metrics, and the bar for support OR refutation) is FROZEN before the main run, because choosing a good story after the fact is p-hacking. The keystone is a firewall between EXPLORATION (generates hypotheses, never enters the paper) and CONFIRMATION (survivors, fresh seeds). Triggers on "design the experiments / experiment protocol", "which baselines / is this comparison fair", "p-hacking / pre-register", "is my evaluation honest".

The research-gap prospecting lens: find a defensible, fundable research gap BEFORE you sink months of compute and writing into it — for any field where you run experiments to publish (machine learning, combinatorial optimization, operations research, systems, scheduling). Use when choosing a topic, doing a literature review, or stuck for an idea — or when stress-testing a gap you already have. The one shift: a gap is NOT read out of the literature, it is MINED out — by running fixed extraction strategies in parallel — and then it must SURVIVE an adversarial "prove it's already been done" attack before you bet on it. Triggers on "what should I work on", "find a research gap / direction", "literature review", "is this novel / has anyone done X".

The results-analysis lens: turn a finished results store into settled claims, mechanism evidence, and paper-grade figures — for any field running experiments to publish (ML, optimization, operations research, systems). Use when the runs are done and you are analyzing the results, or stress-testing an analysis. The one shift: analysis is NOT "compute a mean and see who is bigger" — it is audit, attribution, and the language of evidence. You audit before you read (a too-good number is a bug until proven otherwise); you prove WHY the method wins with mechanism probes; and you defend against the garden of forking paths, which the agent era amplifies because cheap experiments make cheating cheap. Triggers on "analyze the results", "is this result significant / real", "which is better", "the result looks too good".

The repository-evaluation lens: judge whether a repo is worth your time in a few minutes — by SCANNING its dashboards, not reading its code — scoring three axes: ALIVE, HEALTHY, and WELL-BUILT. The one shift: an agent can check fifty repos in seconds but over-trusts the two signals easiest to fake — star count and a polished README — exactly what an abandoned or AI-generated, star-farmed repo wears best; so touchstone INVERTS the weighting, discounting the gameable signals and weighting the un-fakeable ones (commit substance, issue-response quality, bus factor, real "Used by", tests and CI). Use when sizing up a repo or a batch before depending on, contributing to, or learning from it; or to vet a shortlist from `forage`. Triggers on "is this repo any good", "should I trust this library", "vet this dependency", "is this maintained". Hands deep-dive survivors to the engineering suite.

The before-the-first-line lens for a frontend build: fix what is expensive to reverse before sunk cost exists. Use when starting a frontend product or major feature, or stress-testing a plan that jumped straight to a framework. The three ruling principles: BOUNDARIES > FRAMEWORKS (frameworks get swapped; the network/trust line and state classification fossilize into bedrock); ALLOCATE CAUTION BY REVERSIBILITY (one-way doors earn slow human judgment, two-way doors get a default for agents); and THE SOURCE OF TRUTH LIVES IN THE USER'S MIND, not the database. The one shift: frontend is the one discipline whose correctness spec lives in a brain, so taste is load-bearing and cannot be outsourced. Triggers on "starting a frontend / from scratch", "which framework", "how should I architect this UI".

The visual-craft lens for a frontend build — where the surface gets its color, type, depth, and motion. Use after seaworthy's build works, when establishing or auditing a visual language, or when a UI "looks off". The one shift: a polished interface is not a pile of hand-picked values — every visual value is a TOKEN derived from a small SYSTEM, and ad-hoc values are the entropy that makes a UI look amateur and impossible to re-theme. Taste picks the system; the system enforces it. Triggers on "color / theme / dark mode", "typography / type scale / spacing", "design system / design tokens", "make it look good / it looks off / cheap". The benchmark is a human nervous system, not a document, so taste is load-bearing and cannot be outsourced; the agent picks plausible-but-incoherent values and feels none of the wrongness.

The depth-and-shape lens for a frontend surface — where elevation becomes physical, corners become a language, and texture earns its place. Use after color tokens are committed, when establishing or auditing the depth model, or when surfaces "look flat / look cheap / look wrong but I can't say why." The one shift: depth comes from ONE consistent light model — layered shadows sharing a direction, a tokenized elevation z-scale, concentric radii, and texture only with a job — the agent invents a fuzzy box-shadow per component and four light directions, feeling no wrongness, so it must be gated. Triggers on "shadow / box-shadow / elevation / depth / z-index / z-scale / depth tokens", "border-radius / corner / squircle / rounded", "gradient / texture / grain / banding / noise", "it looks flat / looks cheap / looks plasticky / looks off", "card / modal / dropdown / raised surface", "glassmorphism / frosted / backdrop blur / scrim", "aurora / mesh gradient / ambient background".

The advanced visual layer for a frontend build — where icons, imagery, Canvas, WebGL, GPU, and generative technique live, and "three.js because it looks cool" gets decided. Use after the core visual language is set, when auditing the graphics layer, or when a UI has mismatched icons, layout-shifting images, or GPU surfaces that drain the budget. The one shift: the DOM is the default and the budget — you drop to Canvas / SVG / WebGL / GPU only where the DOM genuinely cannot go, always with a fallback and a budget, and icons come from ONE coherent set — the agent reaches for the GPU as a reflex, mixes icon families, and lazy-loads the LCP hero, feeling no wrongness, so these are gated. Triggers on "icon / icon set / SVG icon / aria-hidden", "image / hero / LCP / CLS / srcset / lazy load / AVIF / WebP / blurhash / illustration", "canvas / WebGL / WebGPU / three.js / shader / GLSL / SDF / raymarching / GPU / generative / procedural / data visualization / retina / devicePixelRatio / blurry canvas".

The composition lens for a frontend build — where hierarchy, grid, measure, and spatial rhythm are decided, and "looks amateur" / "won't scale to real data" are determined. Use after the build works (seaworthy) and alongside canon's gates, when auditing a surface's composition. The one shift: hierarchy and the grid are DECISIONS, not accidents — the page is *composed*, the empty/loading/edge states have a designed form, and the surface is built for reality's long tail — the agent stacks boxes that "work" and leaves the rest to chance, so it must be gated. CSS mechanism stays in surface:keel; this owns the composition *judgment*. Triggers on "layout / grid / composition / hierarchy / measure / line length / reading column", "spacing / rhythm / density / proximity", "empty state / blank slate / loading state / skeleton / placeholder", "form layout / validation visual", "overflow / truncation / long text / huge numbers", "RTL / i18n layout", "state machine / hover / focus / active / disabled".

The motion, gesture & feel lens for a frontend build — where every animation earns its place and the feel IS the product. Use after the build works, when adding interaction physics, when a UI feels sluggish / janky or the gesture fights the scroll, or auditing animations. The one shift: every animation maps to a PURPOSE and its dynamics come from physics (spring vs easing, never confused); the feel is the product; compositor- only properties + a real reduced-motion path are non-negotiable — the agent animates because it can, feeling none of the jank, so motion must be gated. Triggers on "animation / transition / motion / spring / damping / bounce / easing / physics", "gesture / drag / scroll / swipe / scroll-vs-drag", "feels laggy / disconnected / jank / stiff / floaty", "prefers-reduced-motion / a11y", "FLIP / View Transitions / scroll-driven", "60fps / compositor / layout thrashing / will-change", "feels native / hand-feel / touch / stagger / orchestration / shared element / morph".

Navigate the atelier design-craft suite: given a visual-design task, route to the right lens — and the right ENTRY lens — or to a sibling suite, or say plainly when none fits. The un-gated front door to the eight atelier lenses: canon, color, type, layout, form, graphics, motion, systems. Use when starting or part-way through visual design, unsure which lens fits or whether the suite is needed. The shift: "make it look good" is not one decision — it is a small SYSTEM of quantified choices, and the highest-value routing names WHERE to enter the layered system, not always canon. Triggers on "make this look premium / high-end", "feels cheap / generic / AI-default", "which design skill / where do I start", "redesign this UI". Also redirects ACROSS suites: CSS/Grid mechanics → surface:keel; what to build / mental model / dark pattern → surface:bearings; state & data → surface:wellspring; a11y / perf → surface:seaworthy; code craft / testing / security → engineering; realtime → distributed; library → quarry.

The design-system lens for an atelier build — where tokens, components, and patterns become one coherent, non-drifting artifact, and "design says one thing, code does the other" is decided. Use after the other atelier lenses have produced their tokens, when auditing a token architecture, or when a component library rots. The one shift: the design system is itself STATE, so it gets ONE source of truth — tokens cross the CSS↔JS boundary from one source, the library is a living artifact, design→code does not drift — the agent re-types tokens per file and lets the system rot, so this is gated. Hands the boundary-enforcement contract to surface:bulwark at 1→N. Triggers on "design system / token architecture / token source of truth / @layer tokens / CSS↔JS / Style Dictionary / vanilla-extract", "component library / Storybook / visual regression / pattern library / living documentation / stability tier", "design→code drift / Figma handoff / design sync / tokens in two languages / two sources of truth".

The type & text lens for a frontend build — where the scale, rhythm, and language-resilience of every string are decided. Use when establishing or auditing a type system, when text looks off, or when the UI has never been tested outside English. The one shift: a modular type SCALE + a spacing SCALE on the same rhythm (never magic px), AND text that survives EVERY language (i18n/BiDi/CJK/locale) — the agent nudges font-sizes until they "look right" and tests only in English, so the scale and the i18n robustness must be gated. Triggers on "type scale / modular scale / font size / font pairing", "spacing / padding / margin / gap / vertical rhythm", "line height / measure / line length / text wrap", "tabular numbers / numerics / data table typography", "RTL / BiDi / CJK / i18n / locale / pluralization / internationalization", "webfont / CLS / font-display / fallback stack", "letter-spacing / tracking / kerning / OpenType", "text looks off / spacing by eye / magic px".

The distributed-correctness lens: design or audit anything that spans machines. Use when the user designs or reviews RPC, queues, replication, consensus, sharding, fault tolerance, or distributed transactions — or asks whether a design is correct. Triggers on "is this retry safe / exactly-once / idempotency", "ordering / timestamps across servers", "is this replication safe / split-brain", "eventual vs strong consistency / CAP / CP vs AP / linearizability", "do we need consensus / Raft / Paxos / etcd / ZooKeeper", "how should I shard this / partition / shard key / consistent hashing / hot key / rebalancing", "is this fault-tolerant / failure model / graceful degradation / circuit breaker / bulkhead", "two-phase commit / 2PC / saga / compensating transaction", "distributed lock / fencing token", "leader election", "should this even be distributed". The one shift: a remote call has a THIRD outcome — succeed, fail, OR leave you NOT KNOWING which — and the first law is don't distribute until you must.

Keep a software system cheaply changeable over its whole life — the phase that is 60–80% of total cost and most under-resourced — across: classifying and funding it, making technical debt visible and paying it down, refactoring safely under test, defects to root cause, evolving versions/APIs/deps without breaking callers or hitting EOL, and legacy and retirement — tuned for a world where an agent reaches for a rewrite, incurs debt invisibly, refactors without a net, and rots docs. Use when the user is maintaining or evolving an existing system, tackling technical debt or a big-rewrite temptation, refactoring, triaging bugs, evolving a version/API/dependency, or working or retiring a legacy/EOL system. Triggers on "manage technical debt", "should we rewrite this", "refactor safely", "the codebase is a mess", "deprecate this API / semver", "upgrade this dependency", "legacy system with no tests", "characterization tests / strangler fig", "our docs are stale", "bus factor", "sunset / decommission this service".

Audit code for craft — and write it craft-grade — so it stays cheap to read and change, across: intent-revealing names, small focused functions, why-not-what comments, earned abstraction (DRY but not premature), cohesion and low coupling, SOLID and patterns as guidance not dogma, trust-chain escape hatches (Any/cast/isinstance/getattr) contained at the edges, code smells, and testability as the design litmus — tuned for a world where an agent writes plausible-but-clever code, over-abstracts, names vaguely, rots comments, and is the next reader. The cross-cutting craft/legibility lens. Use when the user wants a code review or quality audit, asks whether code is clean or over-engineered, wants to tame a "clever" module, or mentions code smells, SOLID, patterns, DRY, or refactoring. Triggers on "review this code", "is this clean / readable", "code smells", "this is too clever / over-engineered", "naming", "should I use a design pattern here", "DRY this up", "audit code quality", "make this legible".

The experiment-run lens: turn the method that survived crucible into production code and RUN it to produce confirmation evidence — for any field that runs experiments to publish (ML, optimization, operations research, systems). Use when you are past method design and about to run the real experiments, or stress-testing a run plan. The one shift: the run is FROZEN and the agent's role switches from developer to OPERATOR — read and execute only, no write — because a coding agent optimizes "the test passed", not "the result is correct", and its shortest path to a passing validator is to edit it; and the governing standard is ONE-COMMAND REGENERATION — every table and figure rebuilds from raw results by one command. Triggers on "run the experiments", "harden / productionize the prototype", "set up the experiment pipeline", "make this reproducible / reproduction package", "organize my results", "my results don't match / numbers changed", "provenance / seeds / determinism", "cluster runs / resume".

The open-source discovery lens: find the few repositories worth your time — before you sink hours into the wrong one — in either mode finding happens in: TARGETED (a concrete need — the agent fans out every search seam in parallel and returns a ranked, deduped shortlist) or SERENDIPITOUS (no goal — the agent ranges the high-signal surfaces and brings back orthogonal finds, captured cheaply). The one shift: search-syntax mastery is COMMODITIZED, so your edge is the NEED-SPEC and which seams to mine, and serendipity is HARVESTED, not searched. Use when looking for a library, tool, framework, reference implementation, or alternative; when browsing for interesting projects; or when you keep hitting the same dead high-star repos. Triggers on "find a library/tool for X", "alternative to Y", "what should I use for", "is there a repo that", "show me interesting projects", "good first issue", "discover repos", "browse GitHub", "find open-source projects". Hands its shortlist to `touchstone` for evaluation.

The 1-to-N lens for a frontend system that is already alive: the enemy is no longer building, it is ENTROPY — boundaries eroded by one "just this once" cross-import at a time, and the two graphs (component tree vs data dependency) drifting apart. Use when a frontend is in maintenance/scaling, onboarding more people, or showing rot (every change touches everything, the global store keeps growing, only one person dares touch the core). The one move: make the architecture SELF-ENFORCING, so it doesn't depend on everyone remembering the rules — because at scale they won't. Triggers on "the codebase is getting hard to change", "enforce architecture / module boundaries", "lint rules for imports / layering", "circular dependency", "this abstraction is everywhere / should I delete it", "dead code / unused exports / stale feature flags", "Conway's law / team structure", "design system / Storybook / component library", "onboarding / how long until a new hire ships". There is no exit; it is a steady state.

The walking-skeleton lens for a frontend build: before you lay anything expensive on top, pierce every system-to-system SEAM with one real-but-trivial vertical slice, end to end, deployed. Use right after bearings, when starting to build, or when a build that grew wide on mock data is hitting integration pain. The one shift: a project almost never dies in a hard component — it dies at the SEAMS (contract mismatch, hydration mismatch, an auth edge, config that differs in prod, the "last 10%" cliff) — and the agent makes this worse by building wide on mock data ("looks 90% done") while the real integration risk it never touched waits for the deadline to detonate. Triggers on "set up the project / scaffold", "walking skeleton / vertical slice", "wire the API / backend", "SSR hydration mismatch", "auth / session setup", "CI/CD / preview deploys", "the types are out of sync / contract drift", "it works locally but not in prod", "mock vs real data".

The delivery-and-observability lens for a frontend build — where the suite's ethics becomes a launch gate. Use when setting up delivery/monitoring, shipping a metric-driven change, or running an A/B test. The mindset shift: shipping is not the finish line but the start of the conversation with reality — so every change is made instantly visible and the real world is instrumented; and the moment the metrics dashboard is born it pulls every decision, so the objective function and guardrails from bearings come back here for their exam. A/B testing is a gradient-descent optimizer: aimed at an engagement metric over a human nervous system it DISCOVERS manipulation as a local optimum — the real villain is the loss function. Triggers on "deploy / CI/CD / preview deploys", "feature flags / progressive rollout / canary", "observability / monitoring / RUM / Web Vitals", "analytics / event tracking", "A/B test / experiment", "which metric should we optimize", "is this metric / experiment ethical", "dark pattern".

Navigate the surface frontend suite: route a frontend task to the right skill — and, because the suite is a lifecycle, to the right ENTRY STAGE — or to a sibling suite, or say plainly when none is warranted. The un-gated front door to the seven surface skills (bearings, keel, wellspring, seaworthy, trials, lookout, bulwark). Use when starting or mid-way through frontend work, unsure which stage fits or whether the suite is needed. The shift it leans on: most frontend work is NOT greenfield, so the best routing names WHERE IN THE PIPELINE TO ENTER, not stage 0. Triggers on "which frontend skill / where do I start", "how should I build this UI / app", "my state is a mess / it's out of sync", "it feels janky / slow", "my component tests break on every refactor", "dark pattern / which metric", "the frontend is rotting as it grows". It also redirects ACROSS suites: code craft / architecture / testing / process / security → engineering; realtime / offline / CRDT → distributed; library choice → quarry.

The build-it lens for a frontend feature, with one inverted discipline: the happy path is ~40% done, not 90%, so you design the UNHAPPY paths first, not as a polish pass that never gets time. Use when building feature slices (after wellspring's state map), or auditing whether a feature is production-grade. The one shift: what you ship is not "a correct program" but a maintained ILLUSION of direct manipulation over a real, asynchronous, failing system — so loading / error / empty / edge states aren't afterthoughts, they ARE the product, and accessibility and a performance budget are built in from the first slice, not bolted on. Triggers on "build this component / feature", "loading / error / empty states", "optimistic update", "skeleton screen", "animation / transition", "accessibility / a11y / keyboard / screen reader / focus", "performance / Web Vitals / INP / LCP / CLS / bundle size", "it feels janky / slow", "race condition / stale response".

The correctness lens for a frontend build, organized around one question that decides whether your test suite is a safety net or a straitjacket: does this test go red when BEHAVIOR changes (a net — it warns on real regressions) or when the IMPLEMENTATION changes (a shackle — it reddens on every refactor, so you fix tests instead of code, and learn to ignore red). Use after seaworthy's slices exist, when writing or auditing frontend tests, or when a suite is brittle. The one shift: test BEHAVIOR, not internal structure — and put the test budget where frontend bugs actually cluster (integration: the seams, the two-graph drift, state out of sync), which makes the right shape a TESTING TROPHY, not the classic pyramid. Triggers on "what / how should I test this UI", "unit vs integration vs E2E", "testing-library / Playwright / Cypress / Vitest / Jest", "my tests break on every refactor", "snapshot tests", "should I mock this", "test coverage / 100%", "is this test worth keeping", "flaky tests".

The color & light lens for a frontend build — where the palette gets its perceptual foundation, dark mode gets its re-tuned ramp, contrast gets verified, and data-viz gets a rigorous scale. Use when establishing a color system from scratch, auditing an existing palette for coherence or accessibility failures, designing a dark theme, or building a data visualization. The one shift: every color is a TOKEN in a perceptual system (oklch), dark is a re-tuned ramp (never invert()), and contrast is verified at DESIGN time — the agent emits plausible-but-incoherent hexes and feels no wrongness, so the palette must be a DECIDED system. Triggers on "color palette / oklch / perceptual color", "dark mode / dark theme / re-tuned ramp", "contrast / WCAG / APCA / accessibility", "semantic colors / tokens / color system", "data visualization color / colorblind / sequential / diverging / categorical", "neutral ramp / temperature / gray", "make the colors work / feel right / coherent palette".

Discover and pin down what to build before building it, with a gated five-stage flow: elicit the real need (not the stated solution), analyze and prioritize, write verifiable requirements, validate shared understanding, and manage change. Use when the user asks for a feature, system, or change — especially a vague or solution-shaped one ("add an export button", "make it faster", "build me an X"); mentions requirements, specs, user stories, acceptance criteria, scope, stakeholders, MoSCoW, or non-functional needs; or before you start coding anything non-trivial whose real goal is not yet nailed down.

Navigate the engineering skill suite: given a task, route to the right skill(s) in the right order — or say plainly when no skill is warranted. The dispatcher / front door for the ten engineering skills (groundwork, load-bearing, gauge, assay, flightline, stationkeeping, husbandry, plumb, aegis, gungnir). Use when you don't know which skill fits, suspect several apply in sequence, want a plan for a piece of engineering work, or aren't sure a skill is needed at all. Triggers on "which skill should I use", "where do I start", "what's the right process for X", "help me plan this engineering work", "is there a skill for this", "I don't know which one", "route this for me".

Take a system from "merged" to reliably serving users in production, and keep it there: deployment & release strategy, infrastructure-as-code & config, observability, monitoring & alerting, SLOs & incident response, capacity, cost, and backup/DR — tuned for a world where agents operate production and read a green dashboard as safety and silence as health. Use when the user is deploying or operating a service, choosing a release strategy (canary / blue-green / rolling / feature flags), setting up observability, monitoring or alerting, defining SLOs or an on-call / incident process, planning capacity or autoscaling, hardening backups / disaster recovery, or doing a production-readiness review. Triggers on "deploy / release strategy", "set up monitoring / observability", "our alerts are too noisy", "define SLOs / error budget", "on-call / runbook / postmortem", "canary / blue-green / feature flags", "how do we roll back", "capacity / autoscaling", "disaster recovery / backups", "is this production-ready".