skills.rest
jonathanrtuck
jonathanrtuckCOMMUNITY
Explore all skills by this author →
GitHub

kernel-auditor

Audit kernel source files for bugs using a six-category checklist and TDD.

1|1|Updated Mar 4, 2026
Search Tags:#tdd#safety#auditing#rust#kernel#bug finding
One-click install
npx skills add https://github.com/jonathanrtuck/os --skill kernel-auditor
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: kernel-auditor
Source: https://github.com/jonathanrtuck/os/tree/main/.factory/skills/kernel-auditor
Command: npx skills add https://github.com/jonathanrtuck/os --skill kernel-auditor

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and scripts (resource) components.

What problem does it solve?

This Skill systematically audits kernel source files for bugs, ensuring memory safety, concurrency correctness, and adherence to architectural design principles.

Core Features & Use Cases

  • Comprehensive Auditing: Applies a 6-category checklist (memory safety, concurrency, error handling, edge cases, resource leaks, AArch64 correctness) to kernel source files.
  • Test-Driven Development (TDD): Writes failing tests before fixing bugs, ensuring verifiable fixes.
  • Use Case: A developer needs to ensure a new kernel module is robust and free of common vulnerabilities before integration. This Skill guides them through a rigorous audit process.

Quick Start

Audit the kernel source file system/src/memory.rs for bugs using the comprehensive checklist.

Frequently Asked Questions about kernel-auditor

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I audit kernel source files for memory safety and concurrency bugs?▼

You audit kernel source files for bugs using a comprehensive 6-category checklist covering memory safety, concurrency, error handling, edge cases, resource leaks, and AArch64 correctness to ensure architectural design adherence.

How does TDD methodology apply to fixing kernel bugs?▼

TDD methodology for kernel bug fixing involves writing failing tests first to reproduce the issue, then fixing the identified bugs, and verifying the resolution passes the full test suite and kernel build.

Can I use this approach to verify AArch64 correctness in my kernel module?▼

Yes, you can verify AArch64 correctness in your kernel module because the auditing checklist explicitly includes AArch64 correctness as one of its 6 core categories for ensuring robust kernel integration.

What is the best way to find resource leaks in Rust kernel code?▼

The best way to find resource leaks in Rust kernel code is to use a systematic auditing checklist that examines edge cases and resource management, paired with writing failing tests to verify the leak before applying fixes.

Do I need to run the full kernel build after fixing an audited bug?▼

Yes, you need to run the full kernel build after fixing an audited bug because the TDD methodology requires verifying the fix by passing both the full test suite and the complete kernel build.

Related Skills

Explore More Software Engineering Skills→
az9713az9713

dark-code-suite-init

Initialize a project with dark code prevention directories, CLAUDE.md section, and baseline audit.

Community
Intermediate
sqjiansqjian

add-sgl-kernel

Add heavyweight AOT CUDA/C++ kernels to sgl-kernel with tests and benchmarks.

Community
Advanced
jimmymalhanjimmymalhan
1

router

Classify incidents into predefined categories and route them in a diagnostic pipeline.

Community
Intermediate
trailofbitstrailofbits
6.5k

rust-review

Audit Rust code for security vulnerabilities across unsafe, concurrency, and FFI boundaries.

Official
Advanced