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".