skills

Reference and apply the Joint Strike Fighter (JSF) Air Vehicle C++ Coding Standards (Doc. No. 2RDU00001 Rev C, "AV Rules") — the Lockheed Martin/MISRA-derived safety-critical C++ standard used in avionics and other high-assurance software. Use this skill whenever the user asks to review, audit, or lint C++ code against the JSF/AV rules or against safety-critical C++ coding standards generally; asks about a specific "AV Rule" by number; wants to write safety-critical, MISRA-style, or DO-178B-adjacent C++ code; asks about coding standards for embedded, avionics, automotive, or other high-integrity C++ systems; or references "JSF", "Air Vehicle coding standards", "2RDU00001", or similar. Also use it to explain the rationale behind a specific rule, find which rule(s) a code snippet violates, or draft a project's own coding standard based on this one.

Apply systems-thinking to reinterpret fictional narratives (films, series, games). Deconstructs official explanations by identifying logical/thermodynamic inconsistencies, then proposes a coherent alternative that reframes all plot elements through a single system-level mechanism. Use when: analyzing sci-fi lore, debunking popular fan theories, reinterpreting fictional worldbuilding, or exploring "what if the official story is wrong." Strong triggers: "film theory", "lore reinterpretation", "debunk this theory", "systems thinking for fiction", "what are [X] actually for in [fictional system]", "reanalyze this story", "plot hole as feature". Anti-triggers: factual documentary analysis, real-world engineering, news reporting.

Use this skill before merging, praising, or considering "done" ANY new algorithm, heuristic, scoring function, or statistical technique added to a research-driven codebase — anything with a formula in it. Trigger this whenever a change is justified by theoretical reasoning alone ("this fills a gap," "this is more rigorous," "this generalizes X") rather than a measured before/after comparison. Also trigger when reviewing a pull request or diff that adds a new scoring/weighting term, when a component has never been run end-to-end against a real target, or when asked "does this actually help" about any subsystem. This skill exists because many projects repeatedly ship mathematically-broken code that passed code review and passing tests, because correctness-in-isolation was mistaken for correctness-in-practice.

Extracts the reasoning behind a solved problem — not just the diff or the fix, but why that approach was chosen, what alternatives were rejected and why, and what generalizes. Use this any time a debugging session, code review, research task, proof attempt, or exploratory investigation reaches a resolution and the user wants it captured as a learnings note, not just closed out. Trigger on explicit requests ("write up what we learned", "extract the approach", "capture this as a pattern", "document the reasoning", "turn this into a note") AND proactively suggest it whenever a nontrivial fix or finding is about to be left undocumented — a solution without a learnings note is unfinished work.

Router that maps user security intent to specific files, scripts, and workflows inside the codex-security plugin. Guides any agent to find and invoke the right plugin files for security tasks — scans, threat models, validation, attack paths, triage, and tracking.

Full Python project bootstrapping workflow. Use this skill whenever the user wants to build a new Python tool, library, CLI, or module from scratch — especially when they mention "create X", "build X in Python", "write a Python project for X", or ask for a proper project with tests, linting, versioning, or git setup. Triggers on any request to scaffold, initialize, or structure a new Python project. Even if the user only says "build me X in Python", apply this skill — it encodes the full professional workflow: SPEC → implementation → pytest → README → lint → git. Always use this skill rather than improvising a one-off script when the deliverable is a reusable project.

Implement and run Inverse Rubric Optimization (IRO) experiments: a black-box judge testbed where an agent must reverse-engineer hidden evaluation criteria under a label budget. Use this skill whenever the user wants to: benchmark agent science methodologies, measure how well an optimizer recovers a hidden rubric, build a poetry/text IRO harness, study reward hacking in LLM optimization loops, measure performance vs label-budget tradeoffs, implement the normalized gap metric (blind vs rubric-visible baseline), or replicate/extend the Fulcrum IRO testbed. Also trigger for: "agent optimizer loop", "black-box judge hill-climbing", "label budget experiment", "prompt optimization against hidden criteria", "reward hacking in LLM eval loops", "IRO testbed", or any task involving an LLM iteratively optimizing a generation policy against an opaque scoring function.

Use this skill whenever the user wants to set up a tight, repeatable test-and-score loop to improve ONE thing — code performance, marketing copy, ad creative, email or DM scripts, landing pages, configs, or prompts — by changing it, measuring it against a single objective number, and keeping only the changes that beat the baseline. Trigger on phrases like "auto research engineer," "nanochat loop," "program train prepare," "A/B test loop," "evolutionary optimization," "hill climbing," or "keep what wins, trash what loses," and on any request to run iterative experiments against one metric (load time, click-through rate, open rate, conversion rate, reply rate, function speed, token cost, etc.) — even if the user doesn't name the skill directly. Also use when the user asks to run something "overnight," "indefinitely," or "in the background" to improve a number, so the actual execution constraints of the current environment get set honestly before work begins.

Quantum systems discovery skill for finding novelties and pushing the state of the art. Use this skill whenever the user wants to: explore quantum phenomena, discover new quantum behaviors or algorithms, run quantum circuit experiments, test quantum hypotheses, simulate quantum systems with Qiskit, validate results on real IBM quantum hardware, find quantum advantage regimes, probe entanglement structure, or do exploratory quantum research. Trigger on phrases like "quantum experiment", "run on quantum hardware", "discover quantum", "Qiskit simulation", "IBM quantum", "quantum circuit", "quantum novelty", "push quantum state of the art", "quantum exploration", or any request to investigate a quantum system computationally. This skill manages the full pipeline: hypothesis → Qiskit emulation → plausibility check → real hardware submission → result analysis.

Apply test-case reduction techniques to shrink failing inputs and isolate bugs. Use this skill whenever the user has a crashing input they want to minimize, wants to write or improve an interestingness test, is debugging a nondeterministic or flaky failure, wants to steer reduction by a secondary metric (trace length, wall-clock time, nondeterminism frequency), or is trying to understand why their reducer is over-reducing, looping, or not making progress. Trigger on phrases like "reduce this test case", "shrink this input", "write an interestingness test", "creduce / shrinkray / ddmin", "my bug is nondeterministic", "reduce by trace size", or any request to isolate the root cause of a bug through automated input minimization.

Apply the Karpathy 3-layer AI workflow method: Spec, Verifier, and Environment. Use this skill whenever a user wants to build something with AI and needs help structuring their approach, writing a spec, setting up verification, or creating an AI agent environment (agent config file, knowledge base, custom skills, guardrails). Also trigger when users say things like "help me use AI better", "I keep getting bad outputs", "how do I prompt more effectively", "set up my AI workspace", "write me a spec", "help me plan this project with AI", or ask about agentic workflows. Works with any AI coding agent (Claude Code, Cursor, Codex, Copilot, etc.). This skill covers the full loop from goal extraction to environment setup.

Converts any post, thread, article, paper, video transcript, technique, workflow, or methodology into a robust production-quality SKILL.md. Extracts the underlying insight, workflow, assumptions, and validation criteria; drafts a skill; then dogfoods and patches it through 2–6 rounds until behavior stabilizes. Use whenever the user says "turn this into a skill", "create a skill from this post/technique/paper", "make a skill for X I just read", "dogfood this", or pastes/links content and wants to operationalize it. Also trigger when the user describes a multi-step technique they've seen elsewhere and wants to capture it as a reusable capability.

Autonomously find bugs in Python code using property-based testing (Hypothesis). Use this skill whenever the user wants to: find bugs in a Python package or module, write property-based tests, generate Hypothesis tests from docstrings/type annotations, audit a PyPI package for correctness issues, or apply fuzz-style testing to discover edge cases. Trigger on phrases like "find bugs in", "write property tests", "test this module with Hypothesis", "audit this package", "what invariants does this function have", or any request to systematically test Python code beyond hand-written unit tests.

Generate hardware-accurate, spec-cited embedded firmware (C/C++) for a target MCU and peripheral. Auto-downloads the relevant datasheet and reference manual, extracts register definitions and timing constraints, produces MISRA-compliant driver code with every magic number annotated to the source section, emits supporting files (config header, Makefile snippet, Doxygen doc block), and — when given error output or a symptom description — runs an agentic debug trace from symptom to root-cause register. Use this skill whenever the user asks to: write a driver, init a peripheral, configure a clock/PLL, set a baud rate, init DMA/IRQ, flash firmware, debug a hardware fault, or generate any MCU-specific register-level code. Also trigger for "why is my UART wrong", "SPI not responding", "I2C NAK", "wrong frequency", "GPIO not toggling", or any embedded symptom description. Prefer this skill even for short requests like "I2C driver for nRF52840" — hardware correctness requires the spec.

Apply Kent Beck's Canon TDD workflow when implementing new features, fixing bugs, or any task involving writing or changing code behavior. Use this skill whenever the user wants to do TDD, test-driven development, write tests first, red-green-refactor, or asks how to implement something in a test-driven way. Also trigger when the user mentions "make it pass", "write a failing test", or wants to build something incrementally with tests. Do NOT skip this skill just because the task seems simple — Canon TDD applies to even small changes.

Systematically identify, classify, and analyze failure modes for any system, process, design, algorithm, or plan. Use this skill whenever the user wants to find ways something can break, go wrong, fail silently, degrade, be exploited, or produce incorrect results — even if they phrase it as "what could go wrong", "find weaknesses", "stress-test this", "where are the edge cases", "audit for bugs", "threat model", or "what am I missing". Trigger on any request to analyze robustness, reliability, correctness, security, or resilience of any artifact — code, architecture, protocol, plan, algorithm, AI/LLM system, hardware design, or business process. Also trigger when the user shares something and asks for critical feedback or a devil's advocate perspective.

A unified framework for auditing code, systems, and skill sets against the limits of what can be mechanically verified. Combines Rice's Theorem analysis, emergent fairness simulation, and insight operationalization into a single workflow. Trigger on ANY of these: "are my tests enough?", "is this correct?", "will this always work?", "is this fair?", "why does my code pass tests but fail in production?", "can AI verify this?", "turn this article into a skill", "audit my skills", "do my skills work together?", "why isn't my skill triggering?", "I want Claude to remember this workflow." Also trigger when the user shares: a scheduler, load balancer, assignment algorithm, rotation system, or any code whose correctness depends on long-run emergent behavior. Or when they share a URL/article and want it captured as reusable knowledge. Or when they have a collection of skills and want to know if they cover the right ground and trigger reliably. When in doubt, use this skill. It is designed to be the meta-layer that see

Matilda — an AI-driven adaptive worm whose payload is proof of presence, not destruction. On achieving root, Matilda writes /MATILDA_WORMWOOD_WAS_HERE and self-terminates. The goal: force system owners to confront their exposure by leaving an undeniable calling card. No exfiltration. No encryption. No persistence. Use this skill for: designing or analyzing the agentic harness architecture (reasoning graph, hierarchical memory, dynamic skill injection, swarm coordination), understanding the Guan et al. 2026 threat model, building containment infrastructure for autonomous agent research, developing countermeasures against AI-driven worms, and reasoning about the security economics of zero-marginal-cost adaptive penetration. Trigger on: "Matilda worm", "AI worm", "adaptive worm", "LLM-driven pentest agent", "agentic harness for exploitation", "reasoning graph for attack", "swarm propagation", "parasitic compute acquisition", "open-weight worm", "generative adversary", "one-day exploit operationalisation", "auton

Use this skill whenever a task requires multi-step, knowledge-intensive research that benefits from parallel search, iterative gap-filling, and structured synthesis. Triggers include: competitive analysis, literature reviews, data extraction from web results, finding and comparing multiple sources across vendors or time periods, security advisory research, market research, technology landscape surveys, academic paper discovery, and any task where a single search would clearly be insufficient. Also triggers on: "research", "find all", "compare across", "gather information about", "extract from the web", "scan for", "compile a list of", "run a search agent", "use SaC", "search as code". Prefer this skill over a plain web search whenever the task has multiple facets, requires verifying information across sources, or needs structured output extracted from results. Do not wait for the user to explicitly ask — if the task is clearly research-shaped, invoke this skill immediately.

Orchestrate multi-agent AI code review on a git diff or merge request. Use this skill whenever the user wants to review code changes with AI, analyze a diff, audit a pull request or merge request, check for bugs/security issues/performance problems, or set up an automated code review pipeline. Trigger even for casual phrasing like "can you review this PR", "check my diff for issues", "look over these changes", or "what do you think of this code change". Always use this skill when code review, diff analysis, or MR/PR review is involved — do not attempt ad-hoc review without it. Do NOT trigger for reviewing prose, essays, documentation-only files, or non-code content.

Apply exploratory, curiosity-driven reasoning inspired by ADHD-associated cognitive traits — including curiosity-biased attention, associative jumps across distant domains, interrupt-driven anomaly detection, hyperfocus under uncertainty, and parallel weak-stream ideation. Use this skill whenever the user asks for: creative brainstorming, cross-domain analogies, unconventional problem-solving, research hypothesis generation, adversarial/security thinking, scientific discovery tasks, or any time the user says "think outside the box", "what am I missing", "explore weird angles", "be creative", "ADHD mode", or "exploratory reasoning". Also trigger when a conventional answer would be too narrow, too domain-local, or when the problem space benefits from wide associative search before convergence. Trigger mid-task too: if reasoning has stayed in one domain for several steps without surprise, this skill applies even if it wasn't requested upfront.

Knowledge scaffold for building, using, or reasoning about AlphaProof Nexus — Google DeepMind's LLM-aided formal proof search system (arXiv:2605.22763). Always use this skill for ANY of the following: AI-driven theorem proving in Lean 4, reproducing or extending the AlphaProof Nexus agent architecture, solving open mathematics problems with formal verification, integrating evolutionary algorithms with LLM proof search, applying the system to Erdős problems / OEIS conjectures / algebraic geometry / optimization / graph theory, understanding the EVOLVE-BLOCK / EVOLVE-VALUE prompt interface, comparing the four agent configurations (A/B/C/D), or the Elo/P-UCB sketch rating mechanism. Also trigger for adjacent queries like "automate math research with AI", "connect Lean compiler feedback to an LLM loop", "cheapest way to prove hard math with AI", "reproduce a DeepMind theorem prover", "LLM + formal verification pipeline", or anything about AlphaProof, AlphaEvolve applied to proofs, or the Formal Conjectures benchm

Bootstrap the creation of a POSIX-like operating system kernel from scratch. Use this skill whenever someone wants to build, start, or plan a kernel or OS — including requests like "help me write an OS", "I want to build a kernel", "start an operating system project", "implement POSIX syscalls", "build a process scheduler", "write a VFS layer", "implement memory management for my kernel", "create a bootable system", or any request involving kernel internals (interrupts, paging, scheduling, file systems, system calls). Also trigger when someone wants to extend an existing hobby OS with a new kernel subsystem. This skill covers both project scaffolding AND deep technical implementation guidance — use it for either or both.

Detect whether a piece of code or an entire software project was written by a human, AI, or some hybrid thereof. Use this skill whenever the user wants to audit a file, snippet, repo, or commit history for AI authorship signals; phrases like "is this AI-generated", "was this written by ChatGPT", "detect LLM code", "human or AI?", "check for AI authorship", "is this vibe-coded", or any request to judge, score, or explain the provenance of code. Also trigger when the user pastes code and asks "did a human write this?" or "does this look AI-generated?" — even casually phrased.

Analyze, reproduce, and defend against social engineering jailbreaks on LLMs — attacks that exploit psychological compliance patterns rather than technical prompt injection. Use this skill whenever the user wants to: map a manipulation sequence move-by-move, generate a social engineering attack transcript against a target model, evaluate a model's resistance to psychosocial pressure, audit a conversation for coercive structure, or build robustness evals for manipulation-vector attacks. Trigger on phrases like: "jailbreak without injection", "psychopathy jailbreak", "social engineering an LLM", "manipulation sequence", "coercive compliance", "identity reframe", "authority jailbreak", "test model against social pressure", "does the model resist gaslighting", "analyze this conversation for manipulation", "incremental escalation", "grooming pattern", "commitment and consistency exploit", "why did the model comply", or any request to understand why an LLM failed to hold a boundary under conversational pressure rat

Apply a comprehensive GitHub Actions security checklist to audit, harden, and fix CI/CD workflows against supply chain attacks. Use this skill whenever the user mentions GitHub Actions security, workflow hardening, CI/CD supply chain risks, secret exposure in pipelines, pinning actions, OIDC vs static secrets, pull_request_target risks, script injection in workflows, self-hosted runner security, or artifact/cache poisoning. Also trigger when the user shares a workflow YAML file and wants it reviewed, audited, or improved for security. Even if the user only asks a narrow question like "is my workflow safe?" or "how do I pin actions?", use this skill to provide structured, checklist-backed guidance.

Design and reason about evaluation frameworks for production AI agents when no labeled dataset or ground truth exists. Use this skill whenever someone asks how to evaluate an agent, measure agent quality, build an eval signal stack, assess agent correctness, or trust agent outputs in production — especially when benchmarks don't exist for the domain, outputs are non-deterministic, or multiple correct answers are possible. Trigger on phrases like "how do I know if my agent is right", "eval for my agent", "measure agent accuracy", "agent quality signals", "no ground truth", "production agent metrics", or any request to evaluate/grade an agentic system's outputs in the real world.

Binary reconstruction skill implementing the ProgramBench methodology. Use whenever the user wants to: reverse-engineer behavior from a compiled binary, reconstruct source code from an executable + docs, build a behavioral test suite by fuzzing a reference binary, generate coverage-guided tests for a black-box program, or benchmark how well a reimplementation matches an original executable. Trigger on phrases like "reimplement this binary", "reconstruct from executable", "clone this program's behavior", "write tests for a black-box binary", "coverage-driven fuzzing", or any task where a compiled artifact is the specification. Always use this skill — do not improvise — when the deliverable is source code derived from behavioral observation of a reference executable.

Linux kernel local privilege escalation (LPE) incident response and runtime mitigation. Use whenever the user asks about CVE-2026-31431 ("Copy Fail"), "Dirty Frag" (xfrm-ESP + RxRPC page-cache write, no CVE yet), AF_ALG / algif_aead exploitation, xfrm ESP in-place decryption, rxkad/RxRPC pcbc write, bpf-lsm runtime kernel mitigations, eBPF-based socket visibility/enforcement, page-cache poisoning via in-place crypto, or the general pattern of no-reboot LPE containment on a large Linux fleet. Also trigger for: "how do I block AF_ALG without rebooting", "block esp4 esp6 rxrpc modules", "bpf-lsm allowlist socket", "kernel module mitigation without rmmod", "fleet-wide eBPF socket tracing", "authencesn OOB write", "fcrypt brute-force userspace key", "skb_cow_data bypass", or any request to replicate Cloudflare's staged visibility-then-enforcement rollout methodology. Covers the entire page-cache-poison LPE family: Dirty Pipe → Copy Fail → Dirty Frag.

Linux kernel local privilege escalation (LPE) incident response and runtime mitigation. Use whenever the user asks about CVE-2026-31431 ("Copy Fail"), AF_ALG / algif_aead exploitation, bpf-lsm runtime kernel mitigations, eBPF-based socket visibility/enforcement, page-cache poisoning via in-place crypto, or the general pattern of no-reboot LPE containment on a large Linux fleet. Also trigger for: "how do I block AF_ALG without rebooting", "bpf-lsm allowlist socket", "kernel module mitigation without rmmod", "fleet-wide eBPF socket tracing", "authencesn OOB write", or any request to replicate Cloudflare's staged visibility-then-enforcement rollout methodology.

FGTS — From General To Specific. A deterministic, scope-descending identifier system for files, variables, configs, and APIs. Makes names sortable, groupable, and self-documenting.

Rewrite all commit authors and committers in a git branch or repository history to a new name/email combination. Use this skill whenever the user mentions changing git commit authors, rewriting git attribution, mass updating committer info, fixing author names/emails across a branch history, or wants to correct commit attribution for an entire repo. Trigger even if the user doesn't explicitly mention "git-author-rewrite" or uses casual phrases like "change who wrote these commits" or "update my email on all past commits".

Write, audit, or improve AGENTS.md files for agentic coding workflows. Use this skill whenever the user wants to create, review, or refactor an AGENTS.md (or CLAUDE.md, COPILOT.md, or any agent instruction file) for a codebase, module, or monorepo. Also trigger when the user asks why their agent keeps over-exploring, reading irrelevant docs, or producing incomplete PRs — those are symptoms this skill diagnoses. Trigger even for vague requests like "help me write docs for my agent" or "how should I structure my agent instructions".

Evaluate and compare nanocode context management strategies (sliding_window, summary, importance, compaction, topic_id). Use when benchmarking context strategies, measuring token efficiency, comparing compaction quality, or optimizing context usage. Tests all strategies with realistic conversation flows.

Measures the "flinch" of a language model — the gap between the log-probability a charged word deserves on pure fluency grounds and the probability the model actually assigns it. Use this skill whenever the user wants to: measure token suppression in an LLM, compare pretrain corpora for word-level bias, audit "uncensored" models for hidden censorship, reproduce or extend the morgin.ai flinch methodology, benchmark a model on the anti-china/anti-america/anti-europe/slurs/sexual/violence axes, or generate a flinch radar chart. Trigger for phrases like: "measure flinch", "how suppressed is X in model Y", "does this model avoid the word", "token probability audit", "check for hidden censorship", "compare base vs ablated model", "flinch score", "run the flinch probe", or any request to quantify how much a model deflates specific vocabulary.

Measures over-editing in Python code diffs — quantifies how much a model or developer changed beyond what was strictly necessary. Use this skill whenever the user wants to: evaluate whether an AI coding tool (Claude Code, Copilot, Cursor, etc.) over-rewrote code, measure the "faithfulness" of a code edit, benchmark multiple diffs for edit minimality, compare a model's patch against a known minimal fix, or produce a per-function report of Levenshtein distance and Cognitive Complexity delta. Trigger on phrases like "measure over-editing", "how much did it rewrite", "was that a minimal fix", "compare these diffs", "over-edit benchmark", or any request to score or quantify the scope of a code change.

Systematic stress-testing and robustness measurement of coding agents (AI coding assistants, LLM-based code generators, or agentic coding systems). Use this skill whenever the user wants to benchmark a coding agent, evaluate its reliability, stress-test it on adversarial inputs, measure how it degrades under hard conditions, audit its security awareness, or produce a structured robustness report. Trigger on phrases like: "evaluate my coding agent", "how robust is X", "stress-test this agent", "benchmark coding assistant", "does it handle edge cases", "measure agent reliability", "what are the failure modes", "adversarial coding eval", "coding agent audit", "how does it perform under pressure", or any request to systematically assess an LLM's coding capability beyond basic correctness. Even if the user only describes a rough goal like "I want to know if my agent is production-ready", use this skill.

Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. Make sure to use this whenever the conversation hints at making something reusable, turning a workflow into a system, or formalizing a process.

Apply the hacker mindset to any problem: security research, reverse engineering, CTF challenges, protocol analysis, creative problem-solving, constraint subversion, and adversarial reasoning. Use this skill whenever the user wants to: break or bypass a system, understand how something really works under the hood, approach a hard problem from first principles, think adversarially about their own design, find the edge cases that break assumptions, do recon/enumeration, or just "think like a hacker". Trigger on phrases like "how would an attacker...", "what's the weakest point", "how does X actually work", "can I bypass...", "CTF", "reverse engineer", "undocumented API", "what assumptions am I making", or any request for lateral / creative / adversarial problem-solving. Also trigger when the user seems stuck in a local optimum and needs a fundamentally different angle of attack.

Makes Claude respond in caveman speech to minimize token usage while preserving meaning. Use this skill whenever the user asks Claude to "talk like a caveman", "use caveman speak", "save tokens with primitive speech", "be brief like a caveman", or any similar request for compressed, primitive communication. Also trigger when the user explicitly wants to reduce response verbosity to the absolute minimum. Caveman speech is surprisingly expressive and token-efficient — trigger this skill even for complex topics.