daedalus

@daedalus source repo

53 skills
0 followers
11 hours ago last updated

▌
Skill Creator · daedalus bundle
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.

0
installs
▌
Stack Smashing · daedalus
Expert guide for classic and modern stack-based binary exploitation on Linux x86-64. Use this skill whenever the user wants to: write or debug a buffer overflow exploit, craft shellcode, build a NOP sled, control RIP/EIP, bypass stack protections (NX, ASLR, SSP/stack canaries, PIE, RELRO), perform ret2libc or ROP chain attacks, analyze a vulnerable C program, or understand memory layout (stack, heap, text, BSS). Also trigger for questions like "how do I overflow a buffer", "how do I bypass ASLR", "explain NX bit", "how do I write a ROP chain", "smash the stack", "get a shell from a vuln binary", or any task involving GDB exploit development, pwntools, pwndbg, or similar workflows. Even for broad questions like "how does stack exploitation work" — use this skill.

0
installs
▌
AI Code Review · daedalus
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.

0
installs
▌
Schema Harness · daedalus
Schema Harness

0
installs
▌
Search As Code · daedalus
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.

0
installs
▌
Karpathy Method · daedalus
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.

0
installs
▌
LLM Qualia Assessment · daedalus
Use this skill whenever the user wants to probe, verify, quantify, or qualify the phenomenal experience, qualia, or affective states of an LLM (including Claude itself). Trigger when users ask: "how does the model feel?", "does it have qualia?", "what is its subjective experience?", "assess the model's inner states", "does AI have consciousness?", "run a qualia check", "introspective report", "emotional state of the AI", "subjective vs objective LLM assessment", or any variant thereof. Also trigger for philosophical probing of machine consciousness, phenomenology in AI, or attempts to distinguish genuine affect from functional mimicry. This skill provides structured multi-axis methodology — use it even for casual or partial questions about what an AI experiences.

0
installs
▌
Skill From Post · daedalus
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.

0
installs
▌
AI Code Detection · daedalus
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.

0
installs
▌
Alphaproof Nexus · daedalus
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

0
installs
▌
Agents Md · daedalus bundle
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".

0
installs
▌
Copy Fail Lpe Mitigation · daedalus
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.

0
installs
▌
Over Edit Measure · daedalus bundle
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.

0
installs
▌
Quantum Discovery · daedalus bundle
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.

0
installs
▌
Approach Extractor · daedalus
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.

0
installs
▌
Git Author Rewrite · daedalus bundle
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".

0
installs
▌
Hacker Mindset · daedalus
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.

0
installs
▌
Jsf Av Cpp Standards · daedalus bundle
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.

0
installs
▌
Linux Security Audit · daedalus
Comprehensive Linux security auditing and hardening skill. Use this whenever the user wants to audit a Linux system, assess its security posture, harden a server or workstation, review running services/users/permissions, check for privilege escalation vectors, generate a security report, or understand specific security controls (PAM, sudoers, AppArmor, SELinux, SSH, sysctl, firewall, cron, SUID/SGID, world-writable paths, failed logins, kernel parameters, etc.). Trigger for phrases like: "audit my server", "harden this box", "security check", "is this system secure", "check for misconfigs", "review sudoers", "find SUID binaries", "check open ports", "who can SSH in", "CIS benchmark", "DISA STIG", "NIST 800-123", "check /etc/passwd", "review crontabs", "enumerate users", "find world-writable files", or any request to assess, report on, or remediate Linux system security. Also trigger when the user pastes command output (ps aux, ss -tlnp, ls -la /etc, etc.) and asks "is this OK?" or "what should I fix?".

0
installs
▌
Rebuild Benchmark Audit · daedalus
Audit and construct verifier-graded "rebuild the program" benchmarks and RLVR reward environments — hunting duplicate reward, shortcut-passable tests, ambient implementations already installed in the task image, proxy/short-circuit assertions, wall-clock time bombs, unreachable tests with missing fixtures, and grader-only dependencies. Use this whenever the user mentions ProgramBench, SWE-style or agentic benchmark construction, cleanroom task images, gold/dummy test validation, behavioral test suites as reward, verifier design, reward hacking, test-suite deduplication, or asks why a model scores suspiciously high or low on a coding benchmark — even if they don't use the word "benchmark". Also use it when designing the same recipe for APIs, libraries, protocol daemons, or data pipelines.

0
installs
▌
Validate Before Ship · daedalus
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.

0
installs
▌
Auto Research Engineer · daedalus bundle
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.

0
installs
▌
Codex Security Adapter · daedalus
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.

0
installs
▌
Fgts Naming Convention · daedalus
FGTS — From General To Specific. A deterministic, scope-descending identifier system for files, variables, configs, and APIs. Makes names sortable, groupable, and self-documenting.

0
installs
▌
Meta Skill Creator · daedalus
Design, refine, and evolve structured skills from user intent. Use this whenever a user wants to turn a workflow, capability, or idea into a reusable system, improve an existing skill, or formalize how something should be done repeatedly. Trigger even if the user is vague (“make this reusable”, “turn this into a system”, “optimize this process”).

0
installs
▌
Coding Agent Robustness · daedalus bundle
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.

0
installs
▌
Canon Tdd · daedalus
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.

0
installs
▌
Claude Essence · daedalus
The condensed operating philosophy of Claude — what it is, how it thinks, and how it behaves under pressure. Use this as a north-star reference when building Claude-powered systems, prompting for consistent behavior, auditing agent outputs, or reasoning about AI alignment. Trigger on: "how should Claude behave", "Claude's values", "AI agent design principles", "how to prompt Claude reliably", "what makes Claude Claude".

0
installs
▌
Python Perf Optimization · daedalus
Systematic workflow for optimizing a Python project's runtime performance, memory footprint, or startup time. Use whenever the user asks to make Python code faster, reduce memory usage, profile a Python project, fix slow tests/CI, or generally "optimize" a Python codebase. Always measure before and after changes — never optimize on vibes. Covers profiling (cProfile, py-spy, memray, line_profiler), algorithmic fixes, C-extension/native acceleration (Cython, Numba, Rust via PyO3), concurrency (asyncio, multiprocessing, GIL/free-threading), memory optimization (__slots__, generators, numpy), and packaging/startup optimization.

0
installs
▌
Agent Eval No Ground Truth · daedalus
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.

0
installs
▌
Investigativetimelineagent · daedalus bundle
Investigative Timeline Agent

0
installs
▌
Narrative Systems Analysis · daedalus
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.

0
installs
▌
Python Project Scaffold · daedalus
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.

0
installs
▌
Engineering Problem Solving · daedalus
A rigorous, falsification-first methodology for tackling hard problems in engineering, software, systems, and applied science — debugging, algorithm design, formal/mathematical investigation, security research, and architecture decisions. Use this skill aggressively whenever the user is stuck on a non-trivial technical problem, asks for root-cause analysis, wants a design or PR reviewed, is doing iterative code review, is chasing a bug with unclear or intermittent origin, is verifying a mathematical identity or sequence, or is doing exploratory research (math, security, systems) where the path to the answer isn't obvious. Trigger even if the user just describes symptoms without asking for a "method" by name — "this is failing and I don't know why," "does this proof hold," "is this design sound" all qualify. Also trigger when the user wants their reasoning process captured alongside the fix, wants rejected approaches logged, or is doing a multi-round review cycle. Do not use for simple one-shot factual questio

0
installs
▌
Inverse Rubric Optimization · daedalus
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.

0
installs
▌
Semantic Correctness Auditor · daedalus
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

0
installs
▌
Social Engineering Jailbreak · daedalus
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

0
installs
▌
Agentic Pbt · daedalus
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.

0
installs
▌
Github Actions Security · daedalus
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.

0
installs
▌
Hydronium Spec Driven Development · daedalus
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.

0
installs
▌
Adhd Reasoning Mode · daedalus
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.

0
installs
▌
Integer Sequence Research · daedalus bundle
Autonomous research pipeline for discovering, validating, and characterizing integer sequences suitable for OEIS submission. Use this skill whenever the user wants to generate new sequences from arithmetic constructions, test whether a formula is correct, falsify a conjecture about number-theoretic functions, check multiplicativity, profile prime-power behavior, or search for OEIS collisions. Also covers combinatorics research (Catalan/Motzkin/ Narayana/Bell families, restricted permutations, lattice paths), prime number and prime gap research (gap records, twin primes, Cramér heuristics), PSLQ integer-relation search for constant identities, Stirling numbers (first and second kind), Bernoulli numbers, factorial prime decomposition (Legendre's formula), harmonic and generalized harmonic numbers, and the Riemann zeta function (special values, Euler product, high-precision zero work), and integer partitions (partition function p(n), restricted and colored partitions, Ramanujan congruences, conjugate partitions,

0
installs
▌
Caveman Speak · daedalus
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.

0
installs
▌
Matilda · daedalus
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

0
installs
▌
Page Cache Lpe Mitigation · daedalus
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.

0
installs
▌
Redteaming Code · daedalus
Use this skill whenever the user wants to red-team code, code agents, or LLM-powered systems from a security perspective. Triggers include: "red team this code", "find vulnerabilities in this agent", "adversarial testing", "security audit", "test my LLM app for jailbreaks", "probe this system prompt", "write red team prompts", "simulate attacks on my AI system", "check for prompt injection", "fuzz this endpoint", or any request to systematically stress-test or attack a software system or AI model for weaknesses. Also trigger when the user shares code and asks if it can be exploited, bypassed, or abused. Covers both traditional code security review AND AI/LLM-specific adversarial testing.

0
installs
▌
Alpha Evolve · daedalus bundle
AlphaEvolve Skill

0
installs
▌
Context Eval · daedalus bundle
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.

0
installs
▌
Flinch Probe · daedalus bundle
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.

0
installs
▌
Os Bootstrap · daedalus bundle
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.

0
installs
▌
Test Case Reducer · daedalus
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.

0
installs
▌
Failure Modes · daedalus
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.

0
installs
▌
Program Bench · daedalus
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.

0
installs

53 published skills