Skill UI

Applies empirically grounded cognitive science frameworks to help CS and AI researchers generate genuinely novel directions through bisociation, analogical reasoning, constraint shifts, and problem reformulation workflows.

This skill teaches the critical principles and decision-making processes for safe production releases. It covers platform selection (e.g., Kubernetes, Vercel), mandatory pre-deployment verification (Code Quality, Environment), structured workflows (Prepare, Backup, Deploy, Verify), and advanced strategies like Blue-Green and Canary deployments. Focuses on thinking through risk mitigation, not just executing scripts.

This comprehensive guide helps developers make critical architectural decisions in modern Node.js development. It covers framework selection (Fastify, Hono, Express), implementing layered architecture, mastering async patterns, robust error handling, and essential security protocols. The focus is on teaching architectural thinking and problem-solving skills, ensuring the development of scalable, high-performance, and maintainable backend APIs.

A comprehensive guide covering the principles of production-grade server management. Topics include process control (PM2, systemd), advanced monitoring strategies (Grafana, metrics), structured logging, scaling decisions (horizontal/vertical), and security best practices. It teaches systematic thinking for ensuring high availability, reliability, and scalability in complex systems.

A deep dive into handling typed content blocks (text, image, tool_use, thinking, document) in LangChain 1.0. This skill standardizes multi-modal message composition, tool-call iteration, and complex content handling across providers like Claude, GPT-4o, and Gemini, solving key API discrepancies.

This advanced methodology builds an evidence-linked causal chain from a localized fault to an actionable systemic root. It moves beyond simple proximate causes by requiring counterfactual testing, verifying multiple independent pathways, and prescribing countermeasures that eliminate enabling conditions, ensuring true recurrence prevention.

This framework applies the Lindy Effect principle to assess the expected remaining life of non-perishable technologies, ideas, or practices. It treats the current survival age as a strong prior for future longevity, guiding users to favor proven, long-surviving options. It is crucial when making critical, high-stakes choices (like selecting frameworks or protocols) where relevance must last years, requiring checks for domain drift and a clear burden of proof before adopting novelty.

A systematic methodology for resolving discrepancies between conceptual models (documentation, tests, diagrams, metrics) and actual observed behavior (live code execution or real data). This process mandates that observed reality (the 'territory') always overrules the theoretical map, ensuring system integrity and accurate knowledge updates.

A systematic planning technique that assumes a project or plan has already failed. By reasoning backward from a catastrophic outcome (in past tense), this method identifies the necessary conditions for failure. These necessary conditions are then inverted into concrete, verifiable preventive requirements, gates, and mitigation strategies, ensuring proactive risk management before execution begins.

A rigorous method for authorized adversarial security review. It models the attacker, maps the entire attack surface (APIs, auth flows, data handling), and generates reports containing only findings with a concrete, reproducible exploit path and verified mitigation steps. Essential for pre-launch hardening and critical system reviews.

A rigorous methodology for debugging complex anomalies or incidents when multiple plausible causes exist. It guides the user to enumerate competing, falsifiable hypotheses and prioritizes running the cheapest, most discriminating observation first. By iteratively eliminating hypotheses and preferring the least-assumptive survivor, it systematically localizes the root cause efficiently.

This methodology guides users to ask critical, load-bearing questions when faced with ambiguous, vague, or assumption-laden requirements. It helps surface hidden requirements and undefined terms, ensuring that the development process is based on explicit, agreed-upon facts rather than guesswork. Use it to define the true problem and scope before committing to a solution.