SKILLS ENCYCLOPEDIA
wei's library → distilled claude capabilities 46 skills
·
372 capabilities
·
9 domains
Security & Hacking
18 skillsBlack Hat Python, 2nd Edition
Python 3 offensive security tooling from scratch — raw sockets to Scapy to Windows internals. Covers networking, packet sniffing, web hacking, Burp extensions, GitHub C2, Windows trojaning (keylogger/shellcode/sandbox detection), data exfiltration, privilege escalation, and Volatility memory forensics.
e.g. Analyzing the GitHub C2 polling pattern to design network and host-based detection signatures for blue team deployment
11 195pp →
Cult of the Dead Cow
History of cDc (Cult of the Dead Cow), the pioneering hacking supergroup that coined hacktivism, built Back Orifice to force Windows security reckoning, testified to Congress under hacker handles, and whose alumni (Mudge/Dildog/Weld Pond) built the modern professional infosec industry.
e.g. Advising a researcher who found a critical flaw in critical infrastructure software with an unresponsive vendor on whether to apply the 90-day coordinated disclosure window or move to immediate publication
6 290pp →
The Ethics of Hacking
Academic ethical framework for political hacking using just-war theory analogues. Argues hacking is justified when protecting vital interests (physical integrity, autonomy, liberty, privacy) and the state fails its protective duty. Six criteria: just cause, right intention, legitimate authority, last resort, proportionality, discrimination.
e.g. Applying the six-criteria framework to the Anonymous HBGary Federal hack — stepping through each criterion — to determine whether it meets the threshold for ethically justified political hacking
6 160pp →
Evading EDR
Windows EDR internals from kernel callbacks to AMSI — how sensors work, what they see, and the architectural principles behind robust detection engineering. Required reading for both detection engineers and red teamers.
e.g. Reviewing a SIEM detection rule for an Office macro attack chain and reformulating it from hash/string matching to behavioral TTP-level logic that survives tooling changes
10 280pp →
Gray Hat Hacking
Comprehensive ethical hacking handbook covering exploit development (Linux/Windows/kernel), C2 deployment and EDR evasion, PowerShell living-off-the-land, Active Directory attacks (Kerberoasting, BloodHound, persistence), IoT/embedded hardware attacks, SDR, cloud hacking (AWS/Azure/containers/Kubernetes), and threat hunting with MITRE ATT&CK.
e.g. Analyzing a 64-bit ELF binary with NX and ASLR enabled to leak a libc address via format string vulnerability and compute the base offset for a Pwntools ROP chain
8 650pp →
Gray Hat Python
Python for Windows security tooling — debugger internals, all three breakpoint types, function hooking, DLL/code injection, fuzzing with Sulley, and IDAPython automation. Uses ctypes to interface directly with the Windows API.
e.g. Implementing a hardware breakpoint on a target function to log call arguments without patching memory (avoiding INT3 detection by the monitored process)
9 200pp →
The Hacker Playbook 3
Red team operations playbook — from recon through web exploitation, AD attack paths, lateral movement, and social engineering. Includes lab exercises and real-world attack chains against simulated environments.
e.g. Analyzing a BloodHound export showing service accounts with SPNs to identify Kerberoasting targets and map the shortest escalation path to Domain Admin
9 280pp →
Hacking & Security
Comprehensive pentesting reference covering Kali Linux toolchain (nmap/hydra/Wireshark/Burp/Metasploit/Empire/Sliver), offline attacks (physical access, BitLocker/LUKS, password reset), web testing (Juice Shop, OWASP methodology), network attacks (ARP poisoning, Responder, pass-the-hash), and defensive hardening (10 steps, CVSS prioritization).
e.g. Generating a custom wordlist from a target company's website with CeWL and running it against captured NTLM hashes from a Responder session using Hashcat with best64 rules
8 800pp →
Hacking APIs
Complete API security testing methodology — from discovery through authentication attacks, BOLA/BFLA, mass assignment, injection, GraphQL-specific attacks, and rate limit bypass. Includes a comprehensive testing checklist.
e.g. Discovering undocumented API endpoints by extracting paths from JavaScript bundles and comparing against published Swagger docs to find delta endpoints excluded from documentation
9 340pp →
Hacking: The Art of Exploitation
Low-level exploitation from first principles — C programming, x86 memory layout, buffer overflows, format strings, shellcode writing, network hacking, and countermeasure bypasses. Erickson explains the 'why' behind techniques rather than just the 'how'.
e.g. Analyzing a vulnerable C program to identify the buffer overflow offset to the return address, determine NX and stack canary status, and construct a return-to-libc payload
10 480pp →
Hacking Kubernetes
Threat-driven Kubernetes security guide: pod hardening (securityContext/capabilities/seccomp), RBAC audit and privilege escalation paths, network policies (default deny), supply chain (Trivy/cosign/SBOM), container runtime isolation (gVisor/Kata), secrets management (Vault/External Secrets), OPA/Gatekeeper policy, and Falco intrusion detection.
e.g. Auditing all service accounts with pods/create or clusterrolebindings/create permissions and generating least-privilege Role/RoleBinding replacements that eliminate the privilege escalation paths
7 240pp →
Handbook of Applied Cryptography
The rigorous academic reference for applied cryptography — block/stream ciphers, cipher modes (ECB/CBC/CTR/GCM), hash functions (birthday bound, collision resistance), RSA (OAEP/PSS), DH/ECDH, ECC, digital signatures (DSA/ECDSA/EdDSA), authentication protocols, key establishment, and cryptographic attack taxonomy.
e.g. Evaluating a proposed AES-CBC-without-MAC encryption scheme and explaining the specific padding oracle and bit-flipping attacks it is vulnerable to, with the correct replacement design
10 800pp →
The Hardware Hacking Handbook
Comprehensive hardware security attack guide — finding debug interfaces (JTAG/UART), firmware extraction (SPI/JTAG), fault injection techniques (voltage/clock/EM/optical), power analysis attacks (SPA/DPA/CPA with Python), real-world examples (PS3, Trezor One, Philips Hue), and countermeasure design.
e.g. Identifying UART and JTAG pin candidates from PCB photos, explaining how to determine baud rate with an oscilloscope, and outlining the steps to obtain a bootloader shell on an IoT device
8 446pp →
Mastering Kali Linux for Advanced Penetration Testing
Advanced Kali Linux pentesting guide: OSINT/stealth recon, wireless attacks (WPA2/WPS/Evil Twin), web exploitation (Burp/sqlmap/BeEF), cloud exploitation (AWS IAM/S3), AV evasion (Veil/fileless/UAC bypass), Metasploit, lateral movement (CrackMapExec/ProxyChains), privilege escalation, and Kerberos golden ticket attack.
e.g. Determining whether to attempt WPS Pixie-Dust via reaver or capture a WPA2 four-way handshake via deauth given a specific access point configuration, then outlining the cracking approach for each path
7 500pp →
Mastering Malware Analysis
Complete malware analysis methodology — from triage through static/dynamic/reverse engineering analysis. Covers anti-analysis bypass, APT techniques, MITRE ATT&CK mapping, IoT malware, and report writing.
e.g. Running a five-minute triage on a suspicious PE binary — hash lookup, strings extraction, import table review, and entropy check — to determine whether full analysis is warranted
10 550pp →
Red Team Field Manual (RTFM)
Compact operator field reference — Linux/Windows command syntax for post-exploitation, networking (tunneling, proxies, pivots), file operations, web attacks, databases, scripting one-liners, and wireless — organized for fast lookup during active engagements.
e.g. Designing a tunneling chain from an external attacker through a DMZ jumphost into a segmented internal network using SSH dynamic forwarding and proxychains with Chisel as fallback
6 96pp →
Social Engineering: The Science of Human Hacking
The complete human hacking framework — from OSINT and target profiling through influence, elicitation, and nonverbals, to the M.A.P.P. defense program. Hadnagy draws on Cialdini, Ekman, and Dreeke to build a science-grounded SE methodology.
e.g. Drafting a pretext phishing email for an authorized pentest engagement that uses authority, urgency, and OSINT-derived organizational context to simulate a realistic credential-harvesting attempt
10 300pp →
ZAP Cookbook
Practical OWASP ZAP recipes for web app pentesting: Docker/GUI setup, Python API automation, spidering (traditional + AJAX), authentication bypass, IDOR, cookie security, CSRF, session hijacking, XSS/SQLi/SSTI/SSRF/command injection fuzzing, business logic manipulation, report generation, and CI/CD integration.
e.g. Writing a ZAP Python API script that spiders a target web application, runs an active scan, filters alerts to High and Critical severity, and outputs a structured JSON report for triage
7 280pp →
C++ & Systems
10 skillsThe Art of Multiprocessor Programming
The definitive textbook on concurrent programming theory — linearizability, mutual exclusion algorithms, lock-free data structures, hardware primitives, and transactional memory. Combines rigorous theory with practical Java implementations.
e.g. Auditing a CAS-based stack implementation, identifying an ABA hazard, and rewriting it using AtomicStampedReference with a stamped version counter
10 530pp →
The Boost Graph Library
Generic C++ graph library: adjacency_list/adjacency_matrix graph classes, BFS/DFS/topological sort/Dijkstra/Bellman-Ford/Kruskal algorithms, property maps, visitor customization hooks, and the concepts-and-models generic programming design pattern that makes all BGL types interoperable.
e.g. Modeling a build system's task dependencies as a directed graph and producing a valid build order using topological_sort while detecting circular dependencies via a DFS back_edge visitor
6 300pp →
C++ Concurrency in Action
Complete guide to C++11 multithreading — from basic thread management and mutex patterns through lock-free data structures and the memory model. Williams is the primary author of the Boost Thread Library and C++11 concurrency proposals.
e.g. Diagnosing a deadlock where two functions acquire two mutexes in opposite order and rewriting them using std::lock()
10 528pp →
C++ in a Nutshell
Complete C++ reference: template mechanics (function/class templates, total/partial specialization, type deduction), type traits with tag dispatch, overload resolution rules, STL container selection guide, iterator categories and safety rules, erase-remove idiom, and custom container design with allocator support.
e.g. Auditing a codebase and flagging all places where std::find is called on associative containers instead of the member .find() method
7 800pp →
C++ Network Programming
Concurrent OO network programming in C++: server architecture patterns (iterative, thread-per-request, thread-per-connection, thread-pool, reactive select-based), process vs thread tradeoffs, synchronization primitives (mutex, RW-lock, condvar, semaphore), socket IPC, non-blocking I/O, and the ACE toolkit wrapper facade philosophy.
e.g. Recommending a reactive select-based server for 10,000 concurrent idle WebSocket connections instead of a thread-per-connection design and sketching the event loop
6 320pp →
The C++ Programming Language
Definitive C++11 reference by Stroustrup: type system, uniform initialization, RAII/ownership, class design (Rule of Five), operator overloading, virtual dispatch, templates, generic programming, variadic templates, metaprogramming, STL containers/algorithms/iterators, lambdas, concurrency (threads/futures/atomics), and C++20 ranges.
e.g. Reviewing a class that manages a raw resource and adding the correct Rule of Five members — copy constructor, copy assignment, move constructor, move assignment, and destructor
7 1346pp →
Programming Principles and Practice Using C++
Stroustrup's C++ pedagogy textbook: class design from struct to class with invariants and pre/postconditions, deep copy semantics (copy constructor + assignment), vector internals (sz/elem/space capacity model, amortized push_back), RAII with exception safety guarantees (basic/strong/no-throw), grammar-to-recursive-descent-parser translation, and embedded systems C++ constraints (no new/delete/exceptions in hard real-time, pool allocators, bitfields).
e.g. Refactoring a BankAccount struct into a class with an enforced non-negative-balance invariant that throws a nested exception type on violation
8 1274pp →
The C++ Standard Library
Complete C++11 Standard Library reference — containers with complexity analysis, 50+ algorithms, iterator categories, move semantics, lambdas, smart pointers, and strings. The definitive STL guide.
e.g. Deciding whether to use map or unordered_map for a cache with 10k entries by explaining the hash vs tree tradeoff and load-factor considerations
9 1100pp →
Effective Modern C++
42 guidelines for effective C++11/14: type deduction (templates/auto/decltype), modern initialization, nullptr/constexpr/override/noexcept, smart pointers, rvalue references, move semantics, perfect forwarding, lambdas, and concurrency with futures and thread_local.
e.g. Tracing why auto x = {1, 2, 3} deduces initializer_list<int> while auto x(1) deduces int and recommending explicit types where the behavior is surprising
6 334pp →
Effective STL
50 specific guidelines for correct, efficient STL usage. Meyers covers the non-obvious pitfalls: container selection traps, iterator invalidation, erase-remove idiom, equality vs equivalence in associative containers, sort algorithm selection, and functor design rules.
e.g. Catching std::find being called on a std::set, explaining the O(n) vs O(log n) difference, and rewriting using the member .find() method
9 260pp →
Linux & OS
4 skillsLinux Device Drivers
The definitive Linux driver development guide — char drivers (file_operations, ioctl, blocking I/O, poll), kernel synchronization (mutex/spinlock/completions), interrupt handling (top/bottom half), DMA (streaming/coherent), block drivers, network drivers (sk_buff), and the Linux device model (kobject/sysfs).
e.g. Generate a complete char driver skeleton for a custom FPGA-attached device that exposes a read/write interface and supports poll() for blocking clients
10 600pp →
Understanding Linux Network Internals
Deep dive into Linux kernel networking internals: sk_buff socket buffer lifecycle (allocation, pointer manipulation, stack traversal), net_device NIC driver registration, softirq receive/transmit path (NAPI), IPv4 forwarding and fragmentation, ARP/neighboring subsystem state machine, and routing table FIB lookup with route cache.
e.g. Implement a NAPI-compliant receive path for a simulated NIC driver including ISR scheduling, the poll() function with budget enforcement, and netif_rx_complete on drain
6 1280pp →
The Definitive Guide to Linux Network Programming
Linux socket programming from first principles: Berkeley socket API lifecycle, three server architectures (iterative/select/fork), TCP vs UDP and stateful vs stateless protocol design, OpenSSL TLS integration (SSL_CTX/SSL layer setup), and secure C coding (buffer overflow prevention, unsafe function replacements, error-handling wrappers).
e.g. Write a single-process TCP echo server using select() that handles up to 64 simultaneous clients without threads, with proper fd_set copy discipline and zombie-safe SIGCHLD handling
7 361pp →
Understanding the Linux Kernel
Comprehensive deep-dive into Linux 2.6 kernel internals — memory addressing (paging/segmentation), process management (task_struct, context switch, CoW), scheduling, synchronization primitives, memory management (buddy/slab), VFS, device drivers, page cache, IPC, and ELF execution.
e.g. Identify why a kernel module locks up under concurrent access by tracing which locks are held, in what order, and whether any code path sleeps while holding a spinlock
10 950pp →
Networking
3 skillsFoundations of Python Network Programming
Python network programming fundamentals: TCP/UDP socket clients/servers, DNS resolution, HTTP/web client and HTML parsing, SMTP/POP/IMAP email, FTP, database clients (DB-API 2.0), SSL/TLS, and concurrency (forking/threading/select/asyncio).
e.g. Build a length-prefixed binary protocol server in Python that handles multiple concurrent clients using asyncio without threads
6 500pp →
TCP/IP Illustrated, Volume 1
The definitive protocol reference — every TCP/IP protocol explained with packet captures and field-by-field analysis. Covers IPv4/IPv6, ARP, ICMP, UDP, TCP (connection, reliability, congestion control), DNS, NAT, and protocol-layer attacks.
e.g. Diagnose why a high-throughput TCP file transfer is underperforming by analyzing cwnd, rwnd, RTT, and retransmit behavior from a pcap
9 1000pp →
Twisted Network Programming Essentials
Twisted event-driven networking for Python: reactor pattern, Protocol/Factory/Transport layering, Deferred callback chains, LineReceiver state machines, Twisted Web server and client, SSH via Conch, and testing with Trial's StringTransport mock.
e.g. Build a multi-stage authentication protocol server using LineReceiver where each client connection transitions through AUTHENTICATE and ACTIVE states
7 200pp →
Algorithms & CS Theory
3 skillsThe Algorithm Design Manual
The practical algorithm designer's reference — technique + problem catalog. Skiena's 'war stories' show how problems arise in practice. The Hitchhiker's Guide catalogs 75 classic problems with implementations.
e.g. Identifying a scheduling system with dependencies as topological sort on a DAG and recommending a shortest-path variant for critical-path analysis
10 730pp →
Cracking the Coding Interview
Comprehensive technical interview prep: Big O analysis, data structures (hash tables, trees, graphs, heaps, tries), algorithm patterns (sorting, searching, DP, recursion, bit manipulation), system design, and behavioral storytelling — with company-specific interview guidance.
e.g. Running a mock interview where Claude poses a graph traversal problem, evaluates brute-force complexity, asks optimization probes, and gives structured feedback on edge-case coverage
6 696pp →
Pearls of Functional Algorithm Design
30 algorithm 'pearls' derived from specifications using equational reasoning in Haskell. Bird demonstrates that efficiency emerges from algebraic manipulation of a correct-but-naive specification — no separate proofs needed.
e.g. Deriving the O(n) maximum segment sum scan from a naive O(n²) fold-of-tails, citing each fusion law applied step by step
8 280pp →
Mathematics
2 skillsElementary Functions: Algorithms and Implementation
Rigorous treatment of transcendental function implementation: IEEE 754 fundamentals (ULPs, rounding modes, FMA, subnormals), polynomial approximation via Chebyshev/Remez minimax, Horner/Estrin evaluation, range reduction (Cody-Waite, Payne-Hanek for large arguments), CORDIC for sin/cos/atan, and correct-rounding via Ziv's multilevel strategy.
e.g. Implementing a double-precision sin(x) using Cody-Waite range reduction to [-π/4, π/4] followed by a degree-11 Horner polynomial targeting faithful rounding within 1 ULP
6 270pp →
Mathematics for Computer Science
MIT's discrete mathematics course textbook — proof techniques (induction, contradiction), number theory (modular arithmetic, Fermat/Euler), graph theory (trees, coloring, planar, Hall's theorem), recurrences (Master Theorem, linear recurrences), counting (combinations, inclusion-exclusion, pigeonhole), probability (Bayes, independence, birthday paradox), random variables (binomial, geometric), expected value (linearity), and tail bounds (Markov, Chernoff).
e.g. Constructing a strong induction proof that a recursive divide-and-conquer algorithm maintains its invariant, then solving the recurrence with the Master Theorem
9 340pp →
Blockchain & Finance
2 skillsInvestment Analysis
Comprehensive investment analysis framework from the canonical graduate-level textbook. Covers portfolio theory, asset pricing, equity and fixed income valuation, derivatives, and performance measurement.
e.g. Providing a company's dividend history, earnings forecasts, and beta so Claude can run a multistage DDM with a CAPM-derived required return and compare implied intrinsic value to the current market price
8 1056pp →
Mastering Bitcoin
Bitcoin protocol internals from first principles — keys, addresses, UTXO model, Script language, P2P network, Merkle trees, mining, and consensus. Antonopoulos frames Bitcoin as a decentralized trust network, not just digital money.
e.g. Evaluating an exchange's stated custody model — hot/cold split, multisig quorum, signing key storage — and identifying gaps in the security hierarchy against the risk profile
10 280pp →
Business & Analysis
3 skillsBusiness Analysis (BABOK v3)
Complete BA knowledge framework from the IIBA BABOK v3. Six knowledge areas, 50 techniques, and five practice perspectives for applying business analysis in any context.
e.g. Generating a structured workshop agenda, facilitation questions, and a blank requirements traceability matrix for a new CRM implementation project
8 512pp →
DAX Mastery
Expert DAX from Ferrari & Russo — the definitive reference. Master evaluation contexts, CALCULATE mechanics, iterators, time intelligence, and advanced data modeling patterns.
e.g. Pasting a DAX measure that returns unexpected totals and having Claude trace the filter context at each CALCULATE call to identify whether context transition or filter replacement is the culprit
8 738pp →
Domain-Driven Design
Tactical and strategic patterns for software where domain complexity is the central challenge. Evans' canonical text distilled into actionable design guidance.
e.g. Reviewing a microservices PR for context boundary violations and suggesting Anticorruption Layer placement where one service's model would corrupt another
8 560pp →
Game Development
1 skills These skills are installable in Claude Code via MCP — coming soon with Skill Forge UPCOMING
46 skills · 372 capabilities · 4,939 books in the library · RSS