NeverSight/NeverC

binary-lifting

Design or debug machine-code lifting into LLVM IR for analysis and recompilation. Use when the lifting pipeline is the subject, not for general binary reverse engineering.

brooks-review

Review existing code or diffs for maintainability, design decay, and architecture risks, reporting actionable Symptom → Source → Consequence → Remedy findings. Do not use for writing code from scratch.

compiler-development

Build NeverC or other LLVM compilers across frontend, IR, optimization, code generation, ABI, and target support. Use when the compiler pipeline is the subject; use narrower LLVM skills for isolated tooling or analysis.

ctf-reverse

Reverse compiled, packed, obfuscated, virtualized, or anti-analysis targets for an authorized CTF challenge. Use while understanding the target; switch to an exploitation skill once the vulnerability is known.

dynamic-instrumentation

Build dynamic instrumentation, runtime tracing, coverage, profiling, or monitoring with LLVM-related tooling. Use static-analysis when execution is not part of the analysis.

github-ci-runtime-debugging

Diagnose NeverC runtime tests that fail only or intermittently in CI. Use for platform-specific crashes, signals, nondeterminism, or local/runner divergence; not ordinary build errors or workflow configuration failures.

llvm-learning

Teach LLVM, Clang, and compiler concepts or assemble a learning path. Use for explanations and educational resources, not implementation work covered by a specialized LLVM skill.

llvm-obfuscation

Analyze or implement LLVM code-protection transformations such as control-flow flattening, string protection, and virtualization. Use when the obfuscation pass or pipeline is the subject.

llvm-optimization

Implement or analyze LLVM optimization passes, pipelines, and generated-code quality. Use for IR transformation and pass behavior, including NeverC compiler performance, not general application tuning.

llvm-security

Apply or develop LLVM sanitizers, compiler hardening, and exploit mitigations. Use when secure compilation is central, not for general vulnerability analysis unrelated to the toolchain.

llvm-tooling

Build Clang plugins, LibTooling tools, LLDB extensions, or clangd/LSP integrations. Use for developer tooling around LLVM, not compiler pipeline implementation.

mlir-development

Build MLIR or CIR dialects, conversions, passes, and multi-level compiler pipelines. Use when MLIR/CIR is the implementation substrate, including ML and domain-specific compilers.

static-analysis

Implement LLVM-based dataflow, pointer, taint, dependency, or verification analyses. Use for static program-analysis algorithms and tools, not runtime instrumentation.

systematic-debugging

Diagnose reproducible bugs and test failures by gathering evidence, isolating the failing boundary, and testing a root-cause hypothesis. Use when the cause is unclear or an attempted fix did not work.

tdd

Build a feature or fix through short red-green-refactor cycles. Use when the user explicitly requests TDD, test-first development, or a red-green-refactor workflow.

technical-cofounder

Turn a product idea into a usable first release across scoping, implementation, polish, and handoff. Use for end-to-end MVP or launch work, not isolated feature requests.

writing-plans

Write an implementation plan from an established specification. Use when the user asks for a plan or when complex work needs a durable handoff before implementation.