메뉴
Detects potential memory leaks in Zig code by checking allocation/deallocation patterns, defer statements, and test cleanup. Use when reviewing code changes, writing new code with allocations, or debugging memory issues.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/code0100fun/botfiles --skill memory-leak-detector명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SOC 직업 분류 기준
SKILL.md 표시 중
| name | memory-leak-detector |
| description | Detects potential memory leaks in Zig code by checking allocation/deallocation patterns, defer statements, and test cleanup. Use when reviewing code changes, writing new code with allocations, or debugging memory issues. |
This skill helps identify potential memory leaks in Zig code by analyzing allocation patterns and ensuring proper cleanup.
Every allocation must have a corresponding deallocation:
Common allocation patterns:
allocator.alloc() -> requires allocator.free()allocator.create() -> requires allocator.destroy()Type.init(allocator) -> requires instance.deinit()ArrayList.init() -> requires list.deinit()HashMap.init() -> requires map.deinit()Proper cleanup pattern:
// GOOD: Immediate defer after allocation
const buffer = try allocator.alloc(u8, 100);
defer allocator.free(buffer);
const instance = try allocator.create(MyType);
defer allocator.destroy(instance);
var list = ArrayList(u8).init(allocator);
defer list.deinit();
Missing cleanup:
// BAD: No cleanup
const buffer = try allocator.alloc(u8, 100);
// Missing: defer allocator.free(buffer)
const instance = MyType.init(allocator);
// Missing: defer instance.deinit()
All test functions must clean up allocated resources:
Proper test cleanup:
test "my feature" {
const allocator = std.testing.allocator;
var server = try Server.init(allocator);
defer server.deinit(); // Cleanup before test ends
const value = try Value.create(allocator, "test");
defer value.deinit(); // Cleanup allocated value
// Test logic here
}
Missing test cleanup:
test "my feature" {
const allocator = std.testing.allocator;
var server = try Server.init(allocator);
// Missing: defer server.deinit()
const value = try Value.create(allocator, data);
// Missing: defer value.deinit()
// Test will leak memory!
}
Handle cleanup in error paths:
Proper error path cleanup:
// GOOD: Arena allocator for automatic cleanup
var arena = std.heap.ArenaAllocator.init(parent_allocator);
defer arena.deinit();
const allocator = arena.allocator();
// All allocations automatically freed on arena.deinit()
Or manual error handling:
// GOOD: Manual cleanup on error
const a = try allocator.alloc(u8, 10);
errdefer allocator.free(a);
const b = try allocator.alloc(u8, 20);
errdefer allocator.free(b);
// If second allocation fails, first is cleaned up
Missing error cleanup:
// BAD: Leak on error
const a = try allocator.alloc(u8, 10);
const b = try allocator.alloc(u8, 20); // If this fails, 'a' leaks
defer allocator.free(a);
defer allocator.free(b);
Types with resources must implement proper cleanup:
Required pattern:
pub const MyType = struct {
allocator: Allocator,
buffer: []u8,
pub fn init(allocator: Allocator, size: usize) !MyType {
const buffer = try allocator.alloc(u8, size);
return MyType{
.allocator = allocator,
.buffer = buffer,
};
}
pub fn deinit(self: *MyType) void {
self.allocator.free(self.buffer);
self.* = undefined; // Safety: prevent use-after-free
}
};
Usage:
var instance = try MyType.init(allocator, 100);
defer instance.deinit(); // Required
For temporary allocations, prefer arena allocators:
Recommended pattern:
pub fn processData(parent_allocator: Allocator) !Result {
var arena = std.heap.ArenaAllocator.init(parent_allocator);
defer arena.deinit(); // Single cleanup for all allocations
const allocator = arena.allocator();
// All temporary allocations use arena
const temp1 = try allocator.alloc(u8, 100);
const temp2 = try allocator.alloc(u8, 200);
// No need for individual defer statements
// All freed automatically on arena.deinit()
return result;
}
// RED FLAG
const data = try allocator.alloc(u8, size);
// Next line should be: defer allocator.free(data)
// RED FLAG: Allocates on every iteration
for (items) |item| {
const temp = try allocator.alloc(u8, item.size);
// Missing cleanup - leaks on each iteration
}
// BETTER: Use arena or defer inside loop
for (items) |item| {
const temp = try allocator.alloc(u8, item.size);
defer allocator.free(temp); // Cleanup each iteration
}
// This is OK - defer runs on all exit paths
const data = try allocator.alloc(u8, 100);
defer allocator.free(data);
if (condition) {
return error.Failed; // defer will run
}
But watch for:
// ACTUAL RED FLAG
const data = try allocator.alloc(u8, 100);
if (condition) {
return error.Failed; // Leaks data
}
defer allocator.free(data); // Too late for early returns
// WATCH OUT: Who owns the memory?
var list = ArrayList(*MyType).init(allocator);
defer list.deinit(); // Only frees the list, not items
const item = try allocator.create(MyType);
try list.append(item); // Must free item separately
// PROPER CLEANUP
defer {
for (list.items) |item| {
allocator.destroy(item);
}
list.deinit();
}
For every allocation:
defer statement?defer immediately after the allocation?For every test:
std.testing.allocator?For every struct with resources:
deinit() method?deinit() free all owned resources?For complex functions:
errdefer used appropriately?Zig's test allocator detects leaks automatically:
test "no leaks" {
const allocator = std.testing.allocator;
// If any allocation isn't freed, test fails
const data = try allocator.alloc(u8, 100);
defer allocator.free(data);
}
Run tests to detect leaks:
zig build test
Leaks will show as test failures with allocation tracking info.
When writing new code:
alloc/create/init has corresponding free/destroy/deinitdefer statement immediately follows allocationerrdeferWhen reviewing code:
defer statementsdeinit implementationsGuide for using bees, a local-first issue tracker (SQLite DB + a committed issues.jsonl) driven by the `bees` CLI. Use for ALL task/issue tracking on bees projects — creating issues, organizing them into epics with dependencies, the in_progress→closed lifecycle, and syncing/committing the tracker.
Guide for creating well-structured conventional commits. Use when creating git commits, drafting commit messages, or reviewing commit message quality.
My personal cross-codebase development workflow — set up tooling with mise, track work in Bees, make focused changes, commit with the commit-message-guide conventions, and land the plane cleanly. Use when starting or running a development task on a project that follows this workflow (mise + Bees + Git).